{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch Normalization\n",
    "One way to make deep networks easier to train is to use more sophisticated optimization procedures such as SGD+momentum, RMSProp, or Adam. Another strategy is to change the architecture of the network to make it easier to train. \n",
    "One idea along these lines is batch normalization which was proposed by [3] in 2015.\n",
    "\n",
    "The idea is relatively straightforward. Machine learning methods tend to work better when their input data consists of uncorrelated features with zero mean and unit variance. When training a neural network, we can preprocess the data before feeding it to the network to explicitly decorrelate its features; this will ensure that the first layer of the network sees data that follows a nice distribution. However, even if we preprocess the input data, the activations at deeper layers of the network will likely no longer be decorrelated and will no longer have zero mean or unit variance since they are output from earlier layers in the network. Even worse, during the training process the distribution of features at each layer of the network will shift as the weights of each layer are updated.\n",
    "\n",
    "The authors of [3] hypothesize that the shifting distribution of features inside deep neural networks may make training deep networks more difficult. To overcome this problem, [3] proposes to insert batch normalization layers into the network. At training time, a batch normalization layer uses a minibatch of data to estimate the mean and standard deviation of each feature. These estimated means and standard deviations are then used to center and normalize the features of the minibatch. A running average of these means and standard deviations is kept during training, and at test time these running averages are used to center and normalize features.\n",
    "\n",
    "It is possible that this normalization strategy could reduce the representational power of the network, since it may sometimes be optimal for certain layers to have features that are not zero-mean or unit variance. To this end, the batch normalization layer includes learnable shift and scale parameters for each feature dimension.\n",
    "\n",
    "[3] [Sergey Ioffe and Christian Szegedy, \"Batch Normalization: Accelerating Deep Network Training by Reducing\n",
    "Internal Covariate Shift\", ICML 2015.](https://arxiv.org/abs/1502.03167)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As usual, a bit of setup\n",
    "import time\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from cs231n.classifiers.fc_net import *\n",
    "from cs231n.data_utils import get_CIFAR10_data\n",
    "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n",
    "from cs231n.solver import Solver\n",
    "\n",
    "%matplotlib inline\n",
    "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n",
    "plt.rcParams['image.interpolation'] = 'nearest'\n",
    "plt.rcParams['image.cmap'] = 'gray'\n",
    "\n",
    "# for auto-reloading external modules\n",
    "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n",
    "%load_ext autoreload\n",
    "%autoreload 2\n",
    "\n",
    "def rel_error(x, y):\n",
    "    \"\"\" returns relative error \"\"\"\n",
    "    return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n",
    "\n",
    "def print_mean_std(x,axis=0):\n",
    "    print('  means: ', x.mean(axis=axis))\n",
    "    print('  stds:  ', x.std(axis=axis))\n",
    "    print() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train:  (49000, 3, 32, 32)\n",
      "y_train:  (49000,)\n",
      "X_val:  (1000, 3, 32, 32)\n",
      "y_val:  (1000,)\n",
      "X_test:  (1000, 3, 32, 32)\n",
      "y_test:  (1000,)\n"
     ]
    }
   ],
   "source": [
    "# Load the (preprocessed) CIFAR10 data.\n",
    "data = get_CIFAR10_data()\n",
    "for k, v in data.items():\n",
    "  print('%s: ' % k, v.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: forward\n",
    "In the file `cs231n/layers.py`, implement the batch normalization forward pass in the function `batchnorm_forward`. Once you have done so, run the following to test your implementation.\n",
    "\n",
    "Referencing the paper linked to above would be helpful!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before batch normalization:\n",
      "  means:  [ -2.3814598  -13.18038246   1.91780462]\n",
      "  stds:   [27.18502186 34.21455511 37.68611762]\n",
      "\n",
      "After batch normalization (gamma=1, beta=0)\n",
      "  means:  [3.99680289e-17 6.93889390e-17 4.41313652e-17]\n",
      "  stds:   [0.99999999 1.         1.        ]\n",
      "\n",
      "After batch normalization (gamma= [1. 2. 3.] , beta= [11. 12. 13.] )\n",
      "  means:  [11. 12. 13.]\n",
      "  stds:   [0.99999999 1.99999999 2.99999999]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after batch normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before batch normalization:')\n",
    "print_mean_std(a,axis=0)\n",
    "\n",
    "gamma = np.ones((D3,))\n",
    "beta = np.zeros((D3,))\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After batch normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)\n",
    "\n",
    "gamma = np.asarray([1.0, 2.0, 3.0])\n",
    "beta = np.asarray([11.0, 12.0, 13.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After batch normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "After batch normalization (test-time):\n",
      "  means:  [-0.03927354 -0.04349152 -0.10452688]\n",
      "  stds:   [1.01531428 1.01238373 0.97819988]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the test-time forward pass by running the training-time\n",
    "# forward pass many times to warm up the running averages, and then\n",
    "# checking the means and variances of activations after a test-time\n",
    "# forward pass.\n",
    "\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 = 200, 50, 60, 3\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "\n",
    "for t in range(50):\n",
    "  X = np.random.randn(N, D1)\n",
    "  a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "  batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "bn_param['mode'] = 'test'\n",
    "X = np.random.randn(N, D1)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "a_norm, _ = batchnorm_forward(a, gamma, beta, bn_param)\n",
    "\n",
    "# Means should be close to zero and stds close to one, but will be\n",
    "# noisier than training-time forward passes.\n",
    "print('After batch normalization (test-time):')\n",
    "print_mean_std(a_norm,axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: backward\n",
    "Now implement the backward pass for batch normalization in the function `batchnorm_backward`.\n",
    "\n",
    "To derive the backward pass you should write out the computation graph for batch normalization and backprop through each of the intermediate nodes. Some intermediates may have multiple outgoing branches; make sure to sum gradients across these branches in the backward pass.\n",
    "\n",
    "Once you have finished, run the following to numerically check your backward pass."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.7029261167605239e-09\n",
      "dgamma error:  7.420414216247087e-13\n",
      "dbeta error:  2.8795057655839487e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "fx = lambda x: batchnorm_forward(x, gamma, beta, bn_param)[0]\n",
    "fg = lambda a: batchnorm_forward(x, a, beta, bn_param)[0]\n",
    "fb = lambda b: batchnorm_forward(x, gamma, b, bn_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "dx, dgamma, dbeta = batchnorm_backward(dout, cache)\n",
    "#You should expect to see relative errors between 1e-13 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Batch normalization: alternative backward\n",
    "In class we talked about two different implementations for the sigmoid backward pass. One strategy is to write out a computation graph composed of simple operations and backprop through all intermediate values. Another strategy is to work out the derivatives on paper. For example, you can derive a very simple formula for the sigmoid function's backward pass by simplifying gradients on paper.\n",
    "\n",
    "Surprisingly, it turns out that you can do a similar simplification for the batch normalization backward pass too.  \n",
    "Given a set of inputs $X=\\begin{bmatrix}x_1\\\\x_2\\\\...\\\\x_N\\end{bmatrix}$, \n",
    "we first calculate the mean $\\mu=\\frac{1}{N}\\sum_{k=1}^N x_k$ and variance $v=\\frac{1}{N}\\sum_{k=1}^N (x_k-\\mu)^2.$    \n",
    "With $\\mu$ and $v$ calculated, we can calculate the standard deviation $\\sigma=\\sqrt{v+\\epsilon}$  and normalized data $Y$ with $y_i=\\frac{x_i-\\mu}{\\sigma}.$\n",
    "\n",
    "\n",
    "The meat of our problem is to get $\\frac{\\partial L}{\\partial X}$ from the upstream gradient $\\frac{\\partial L}{\\partial Y}.$ It might be challenging to directly reason about the gradients over $X$ and $Y$ - try reasoning about it in terms of $x_i$ and $y_i$ first.\n",
    "\n",
    "You will need to come up with the derivations for $\\frac{\\partial L}{\\partial x_i}$, by relying on the Chain Rule to first calculate the intermediate $\\frac{\\partial \\mu}{\\partial x_i}, \\frac{\\partial v}{\\partial x_i}, \\frac{\\partial \\sigma}{\\partial x_i},$ then assemble these pieces to calculate $\\frac{\\partial y_i}{\\partial x_i}$. You should make sure each of the intermediary steps are all as simple as possible. \n",
    "\n",
    "After doing so, implement the simplified batch normalization backward pass in the function `batchnorm_backward_alt` and compare the two implementations by running the following. Your two implementations should compute nearly identical results, but the alternative implementation should be a bit faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx difference:  1.07333843309325e-12\n",
      "dgamma difference:  0.0\n",
      "dbeta difference:  0.0\n",
      "speedup: 34.03x\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D = 100, 500\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "bn_param = {'mode': 'train'}\n",
    "out, cache = batchnorm_forward(x, gamma, beta, bn_param)\n",
    "\n",
    "t1 = time.time()\n",
    "dx1, dgamma1, dbeta1 = batchnorm_backward(dout, cache)\n",
    "t2 = time.time()\n",
    "dx2, dgamma2, dbeta2 = batchnorm_backward_alt(dout, cache)\n",
    "t3 = time.time()\n",
    "\n",
    "print('dx difference: ', rel_error(dx1, dx2))\n",
    "print('dgamma difference: ', rel_error(dgamma1, dgamma2))\n",
    "print('dbeta difference: ', rel_error(dbeta1, dbeta2))\n",
    "print('speedup: %.2fx' % ((t2 - t1) / (t3 - t2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fully Connected Nets with Batch Normalization\n",
    "Now that you have a working implementation for batch normalization, go back to your `FullyConnectedNet` in the file `cs231n/classifiers/fc_net.py`. Modify your implementation to add batch normalization.\n",
    "\n",
    "Concretely, when the `normalization` flag is set to `\"batchnorm\"` in the constructor, you should insert a batch normalization layer before each ReLU nonlinearity. The outputs from the last layer of the network should not be normalized. Once you are done, run the following to gradient-check your implementation.\n",
    "\n",
    "HINT: You might find it useful to define an additional helper layer similar to those in the file `cs231n/layer_utils.py`. If you decide to do so, do it in the file `cs231n/classifiers/fc_net.py`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running check with reg =  0\n",
      "Initial loss:  2.2611955101340957\n",
      "W1 relative error: 1.10e-04\n",
      "W2 relative error: 2.85e-06\n",
      "W3 relative error: 3.92e-10\n",
      "b1 relative error: 4.44e-08\n",
      "b2 relative error: 2.22e-08\n",
      "b3 relative error: 4.78e-11\n",
      "beta1 relative error: 7.33e-09\n",
      "beta2 relative error: 1.89e-09\n",
      "gamma1 relative error: 7.57e-09\n",
      "gamma2 relative error: 1.96e-09\n",
      "\n",
      "Running check with reg =  3.14\n",
      "Initial loss:  6.996533220108303\n",
      "W1 relative error: 1.98e-06\n",
      "W2 relative error: 2.28e-06\n",
      "W3 relative error: 1.11e-08\n",
      "b1 relative error: 5.55e-09\n",
      "b2 relative error: 5.55e-09\n",
      "b3 relative error: 2.23e-10\n",
      "beta1 relative error: 6.65e-09\n",
      "beta2 relative error: 3.48e-09\n",
      "gamma1 relative error: 5.94e-09\n",
      "gamma2 relative error: 4.14e-09\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "N, D, H1, H2, C = 2, 15, 20, 30, 10\n",
    "X = np.random.randn(N, D)\n",
    "y = np.random.randint(C, size=(N,))\n",
    "\n",
    "# You should expect losses between 1e-4~1e-10 for W, \n",
    "# losses between 1e-08~1e-10 for b,\n",
    "# and losses between 1e-08~1e-09 for beta and gammas.\n",
    "for reg in [0, 3.14]:\n",
    "  print('Running check with reg = ', reg)\n",
    "  model = FullyConnectedNet([H1, H2], input_dim=D, num_classes=C,\n",
    "                            reg=reg, weight_scale=5e-2, dtype=np.float64,\n",
    "                            normalization='batchnorm')\n",
    "\n",
    "  loss, grads = model.loss(X, y)\n",
    "  print('Initial loss: ', loss)\n",
    "\n",
    "  for name in sorted(grads):\n",
    "    f = lambda _: model.loss(X, y)[0]\n",
    "    grad_num = eval_numerical_gradient(f, model.params[name], verbose=False, h=1e-5)\n",
    "    print('%s relative error: %.2e' % (name, rel_error(grad_num, grads[name])))\n",
    "  if reg == 0: print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batchnorm for deep networks\n",
    "Run the following to train a six-layer network on a subset of 1000 training examples both with and without batch normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Iteration 1 / 200) loss: 2.340974\n",
      "(Epoch 0 / 10) train acc: 0.107000; val_acc: 0.115000\n",
      "(Epoch 1 / 10) train acc: 0.314000; val_acc: 0.267000\n",
      "(Iteration 21 / 200) loss: 2.039344\n",
      "(Epoch 2 / 10) train acc: 0.396000; val_acc: 0.280000\n",
      "(Iteration 41 / 200) loss: 2.047471\n",
      "(Epoch 3 / 10) train acc: 0.484000; val_acc: 0.316000\n",
      "(Iteration 61 / 200) loss: 1.739554\n",
      "(Epoch 4 / 10) train acc: 0.522000; val_acc: 0.319000\n",
      "(Iteration 81 / 200) loss: 1.246973\n",
      "(Epoch 5 / 10) train acc: 0.591000; val_acc: 0.339000\n",
      "(Iteration 101 / 200) loss: 1.358532\n",
      "(Epoch 6 / 10) train acc: 0.639000; val_acc: 0.322000\n",
      "(Iteration 121 / 200) loss: 0.974635\n",
      "(Epoch 7 / 10) train acc: 0.660000; val_acc: 0.329000\n",
      "(Iteration 141 / 200) loss: 1.200129\n",
      "(Epoch 8 / 10) train acc: 0.680000; val_acc: 0.297000\n",
      "(Iteration 161 / 200) loss: 0.792859\n",
      "(Epoch 9 / 10) train acc: 0.783000; val_acc: 0.342000\n",
      "(Iteration 181 / 200) loss: 0.761618\n",
      "(Epoch 10 / 10) train acc: 0.743000; val_acc: 0.305000\n",
      "(Iteration 1 / 200) loss: 2.302332\n",
      "(Epoch 0 / 10) train acc: 0.129000; val_acc: 0.131000\n",
      "(Epoch 1 / 10) train acc: 0.283000; val_acc: 0.250000\n",
      "(Iteration 21 / 200) loss: 2.041970\n",
      "(Epoch 2 / 10) train acc: 0.316000; val_acc: 0.277000\n",
      "(Iteration 41 / 200) loss: 1.900473\n",
      "(Epoch 3 / 10) train acc: 0.373000; val_acc: 0.282000\n",
      "(Iteration 61 / 200) loss: 1.713156\n",
      "(Epoch 4 / 10) train acc: 0.390000; val_acc: 0.310000\n",
      "(Iteration 81 / 200) loss: 1.662209\n",
      "(Epoch 5 / 10) train acc: 0.434000; val_acc: 0.300000\n",
      "(Iteration 101 / 200) loss: 1.696059\n",
      "(Epoch 6 / 10) train acc: 0.535000; val_acc: 0.345000\n",
      "(Iteration 121 / 200) loss: 1.557986\n",
      "(Epoch 7 / 10) train acc: 0.530000; val_acc: 0.304000\n",
      "(Iteration 141 / 200) loss: 1.432189\n",
      "(Epoch 8 / 10) train acc: 0.628000; val_acc: 0.339000\n",
      "(Iteration 161 / 200) loss: 1.033932\n",
      "(Epoch 9 / 10) train acc: 0.661000; val_acc: 0.340000\n",
      "(Iteration 181 / 200) loss: 0.901034\n",
      "(Epoch 10 / 10) train acc: 0.726000; val_acc: 0.318000\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [100, 100, 100, 100, 100]\n",
    "\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "weight_scale = 2e-2\n",
    "bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "bn_solver = Solver(bn_model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True,print_every=20)\n",
    "bn_solver.train()\n",
    "\n",
    "solver = Solver(model, small_data,\n",
    "                num_epochs=10, batch_size=50,\n",
    "                update_rule='adam',\n",
    "                optim_config={\n",
    "                  'learning_rate': 1e-3,\n",
    "                },\n",
    "                verbose=True, print_every=20)\n",
    "solver.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Run the following to visualize the results from two networks trained above. You should find that using batch normalization helps the network to converge much faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3QAAANsCAYAAAATFepNAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3X90HPV5L/73s9IKr0KwwDJ1Jdmxk8sxJcZgkBMa6Xsb7AsOMTgOJYIQWnpbanJpIPikNiKHa1Q3jRW7jYnJpcR1cmgO+YGagC1iuMDFoakcKLYxMS6BEn6klgQBGWR+aI1+7Of7x+xKs7MzO/PZmdmdWb1f5/gYzc7Ozs6uk3n0PJ/nEaUUiIiIiIiIKH4SlT4BIiIiIiIiKg0DOiIiIiIiophiQEdERERERBRTDOiIiIiIiIhiigEdERERERFRTDGgIyIiIiIiiikGdEREVDVEpEZE3hWReUHuW8J5fE1E7gr6uERERFa1lT4BIiKavkTkXdOP9QDeBzCR/flapdQPdI6nlJoAcGLQ+xIREUUVAzoiIqoYpdRkQCUirwC4Rin1/5z2F5FapdR4Oc6NiIgoDlhySUREkZUtXbxHRH4kIu8AuEpE/lBEnhCRYRF5VUS2iUgyu3+tiCgRmZ/9+e7s4w+KyDsi8riILNDdN/v4RSLynyJyTERuF5G9IvJnHt/HahH5j+w57xGRhabHvioigyLytog8JyKfzG4/T0Seym7/nYhsCeCSEhFRlWFAR0REUfdZAD8EMBPAPQDGAXwZQCOANgCfAnBtkedfCeB/AzgFwH8B+FvdfUXkVAA9ANZlX/dlAB/zcvIi8gcA7gZwPYDZAP4fgPtFJCkiH82e+zlKqZMAXJR9XQC4HcCW7Pb/BuAnXl6PiIimFwZ0REQUdX1KqfuVUhmlVFoptU8p9e9KqXGl1EsAtgP4oyLP/4lSar9SagzADwCcXcK+FwN4Wim1K/vYVgBDHs//CgC9Sqk92ed2AzgJwMdhBKczAHw0W076cvY9AcAYgNNEZJZS6h2l1L97fD0iIppGGNAREVHUHTH/ICKni8huEXlNRN4GsBFG1szJa6b/HkHxRihO+zaZz0MppQD0ezj33HN/a3puJvvcZqXU8wC+AuM9vJ4tLZ2T3fV/AjgDwPMi8qSIfNrj6xER0TTCgI6IiKJOWX7+DoDDAP5bthxxAwAJ+RxeBdCS+0FEBECzx+cOAviQ6bmJ7LEGAEApdbdSqg3AAgA1ADZltz+vlLoCwKkA/gHAT0Vkhv+3QkRE1YQBHRERxc0HARwD8F52fVqx9XNB+RmAc0TkEhGphbGGb7bH5/YAWCUin8w2b1kH4B0A/y4ifyAi54vICQDS2T8TACAifyIijdmM3jEYgW0m2LdFRERxx4COiIji5isAroYRFH0HRqOUUCmlfgfgcgDfBHAUwEcAHIQxN8/tuf8B43z/EcAbMJq4rMqupzsBwGYY6/FeA3AygFuyT/00gF9nu3v+PYDLlVKjAb4tIiKqAmIsAyAiIiKvRKQGRinlZUqpf6v0+RAR0fTFDB0REZEHIvIpEZmZLY/83zA6VD5Z4dMiIqJpjgEdERGRN+0AXoJRHvkpAKuVUq4ll0RERGFiySUREREREVFMMUNHREREREQUU7WVPgE7jY2Nav78+ZU+DSIiIiIiooo4cODAkFLKdUROJAO6+fPnY//+/ZU+DSIiIiIioooQkd962Y8ll0RERERERDHFgI6IiIiIiCimGNARERERERHFFAM6IiIiIiKimGJAR0REREREFFMM6IiIiIiIiGIqkmMLombnwQFseeh5DA6n0dSQwroVC7F6SXOlT4uIiIiIiKY5BnQudh4cwM33PoP02AQAYGA4jZvvfQYAGNQREREREVFFseTSxZaHnp8M5nLSYxPY8tDzFTojIiIiIiIiAwM6F4PDaa3tRERERERE5cKAzkVTQ8p2uwLQ1r0HOw8OlPeEiIiIiIiIsriGzsW6FQvRd98duBE/RpMM4S11IkSABryLwZFG/Ot9SzDy8GHUp18DZrYAyzcAizsqfdpERERERDQNiFKq0udQoLW1Ve3fv7/Sp2E41IPxXdejduK47cNKASKmDYkkcMIHgfRbRoB32oXACw8Dx/rtf2YASEREREREFiJyQCnV6rofAzoXWxcBx46Ed/xkCrhkWzBB3aEe4NGNDBaJiIiIiGLOa0DHNXRujvWHe/yxtBGE+XWoB7j/hmzwqYy/77/B2E5ERERERFWJAZ2bmS3hv4bXoPFQj5Ex7Gow/jYHa49uNIJDs6CCRSIiIiIiiiQGdG6WbzDKIh0EUrHqJWh0y8A5BYVhZxiJiIiIiKhiXAM6EZkrIj8XkV+LyH+IyJdt9vmCiBzK/vmliJxleuwVEXlGRJ4WkYgsjNOwuMNY4zZzLgABUqcYfyB4DbPx/Yn/gf5MIzJKcDRzIkaVZuPQZMoIGgF/GTinoNBpe7HXIiIiIiKiWPASfYwD+IpS6ikR+SCAAyLyiFLqWdM+LwP4I6XUWyJyEYDtAD5uevx8pdRQcKddZos7bJuLPHFwAN33PoNbRycmt322di/W1d6DOeooXpdGvPeh5fjI8F73Lpe5DFwuaMtl4HKv75aBW74h//lAfrBo5vZaREREREQUC64BnVLqVQCvZv/7HRH5NYBmAM+a9vml6SlPACjDwrPKW72kGQCw5aHnMTicxsxUEj8bbcd9x9sm90m9VINNl26Y3LdALlNm10kzl4Fb3GEEf3b75DJwuUDMS5fLYtk+BnRERERERLGhVR8oIvMBLAHw70V2+wsAD5p+VgAeFhEF4DtKqe0Ox14DYA0AzJs3T+e0Kmr1kubJYK2tew+G02N5j6fHJrDloeftAzprpsxOsQxcIgmMvmeUTeYCuLWH3U+a6+2IiIiIiKqC56YoInIigJ8CuFEp9bbDPufDCOhuMm1uU0qdA+AiAH8lIv/d7rlKqe1KqValVOvs2bM9v4EoGRy2D8yctttmyixGUnOM/7BbyycCpN+E9pgC3fV2REREREQUSZ4ydCKShBHM/UApda/DPosB7ABwkVLqaG67Umow+/frInIfgI8B+IXfE4+ipoYUBmyCt4QIFnTuRlNDCuefPhs/f+4NDA6n8eKM/qIR9Yiqw+axy9GV22Bey7d1UTaYM/FaNqmz3o6IiIiIiCLLS5dLAfBdAL9WSn3TYZ95AO4F8CdKqf80bf9AtpEKROQDAC4E4KEmMJ7WrViIVLKmYPuEUlAABobTuPuJ/8LAcBoKwGBmlu1xlAL6M43oHLsG//zux+xfzE/ZpDXbN3Ou8TPXzxERERERxYqXDF0bgD8B8IyIPJ3d9lUA8wBAKXUngA0AZgG4w4j/MK6UagXwewDuy26rBfBDpdT/DfQdRIi1SUpCBBNFBtVtHu9Ad3IH6mV0ctuIqkPn2DXozbQDAJobHGbguTVJcePQuZOIiIiIiOJDVCCTsYPV2tqq9u+P38g6qwWdu+F2dVcl+rC+tgdNchSDahY2j3dMBnOpZA02XXqm94YqyRQzbUREREREVUBEDmSTZEVpTsEmHU5r6sx6M+3oHW0v2N7ckMK6FQudxx3ojCkgIiIiIqKqxIAuROtWLMTN9z6D9NiE+84mzQ0p7O1clp1RNxWw7fvI9bjx2dMwOJxGU0MK61a0YbWXMQVERERERFSVPI8tIH2rlzRj06VnorkhBYERqF113rzJnxtSSSRrJO85qWQN1q1YOFVSeewIcmMJFh24Bee+/chkg5Wb730GOw8OOJ9Abmh5V4Pxt5eRBkREREREFBtcQ1dhOw8OTDZRaTKXWW5dZNv0pD/TiPbRbZM/T2bzLMe6+sQncYu6E7UTx6eezDV2RERERESxwDV0MbF6SbP9OjmH8QNNcjTv59zQ8p0HB/LKO68ZvRu1ieP5Tx5LA/f+pbHuzmW9nTXQvO2MF7D0xdu5Xo+IiIiIKEIY0EWVw1iCQZU/u64pO9Zgy0PP563Va5Ih52MfO2KUcwK2QZk1ODz37Uew6MAOIDdeweX5RERERERUHlxDF1H7PnI90qoub9uIqsPm8akAanK9HaYydTmDqrH4C4yl8dq9X8WCzt1o696Dfb3fmVxvd96uP8IFE/86uev62h6kTLPycs/HoxtLeGdERERERBQUBnQRdeOzp+GmsWvQn2lERgn6M43oHLsGu9X/N9lgxTyjrskygHzzeAdGLAGh1alqCAq5DNwtkw1Y5uANdCd3YFWizzi2U7bPoSyUiIiIiIjKgyWXETU4nMYACmfUCRRe7l4JwCiNbOveg8HhNGZmO2aOTRhNbnoz7ahTCWys/ynq06/av0a2fNMuA1cvo1hf24Pe0XYMqka02AV1M1v8vk0iIiIiIvKBGbqIsmbcrNtz69wGhtNQAIbTY4ACTq5PTmbw2j97Hepveg649J+MDpcm5vJNpwxcrgHL5vGOgvJPJFNGYxQiIiIiIqoYZugiym4ouXnNnLUJCgCMZRTq62pxcMOF+Qdb3IF9r7yFuU9twalqCK9iFr4x1oHejJH9c8rAZUTw0glX4nWZjadPWYkFb/bhVDWE16URR85ch6VsiEJEREREVFEM6CIqtzbOdkYdCpug5Nht33lwADfv+xDSY9+yfc7m8Q58I7mjoOyyFhlAgDl4AzOP7sZNY9dMBoGpfTXYNHfAfuRChDjO+SMiIiIiqgIM6CLMcUYdjNLLAZvgza5U0y6bBwA1IsgohQMnXYDDZ8yfmjMnCUDl758yrakDgPTYBLY89HykgyPr+IWB4TRuvvcZAIj0eRMRERERecWALqbcSjLNnLJ5GTXVYAVYBuBa4z+7Gmz3dxpqXlaHeoxxCR4GnNsFsnEIRImIiIiIvGJAF1NuJZnAVLmhcjiGU+MVt6HmqxJ9WF/bg6bEUWBr8aDKN3MAlzoZGH0XmPA24FynLJWIiIiIKI4Y0MVYsZJMa7mhlVM2D4ARoN1/gzE8PCud7Yq5KtGH7uQO1Iu3oMqXQz3555F+s3Cf3IBzm9fWKUslIiIiIoojji2oUk7r5oDCoeQFFncAl2wDZs4FIMDMuTh87tdw4KQLsL62ZyqYy8kFVTmHeoCti4zSza2LjJ9L8ejGvKDSkXnAuem1H5HrcFndL/N2LRrIVlBupuCCzt1o696DnQcHKn1KlRXUd4iIiIioyjFDV6WcygoFwN7OZQXbC7tBtmH12sOTjy8FsHcVgK6jBc8FMBVUHerB+K7rUTtxPLv9iPEzoJ/BMwdqxeQGnFsyevXpV/GNmjtxy4x/xknqHbwus3HknHVYuuRT9sfRWJ8XJDZvsbBmZsPMAhMRERHFHDN0VcptMLmZdUh5LqCwzRLlgieH7SMPbpgK5rJqJ45j5MEShpA7vZaZecC5TUavRo2jAe8gkR2/sPSZW+2zPbkg4tgRAGoqiChDZqhY85ZpyS4za80CExEREREABnRVa92KhUgla/K2OZUbagUUyzcYQZSZKaiakX7N9nycthdl91qJJJA6BblSUFyybSpr4yWj5xQYVDCIYPMWC6fP0WvGloiIiGgaYclllfLSBTNHK6DIBU/m0sTTLjR+vncNMkqQkMK+moOZWXDMtzmVOtq9VrEySIfunAXsAoMKBhFs3mLh9Dl6ydgSERERTTOuAZ2IzAXwfQBzAGQAbFdKfcuyjwD4FoBPAxgB8GdKqaeyj10N4Jbsrl9TSv1zcKdPxRTrgmmmG1DsnGjDlve3YfB4GlfXPolbDt45WWZZKwpKASJT+4+oOuyouwpddgdzWy9lDuzc2HTntGUXGFQwiNCZKTgt2H2O5tJaIiIiIprkpeRyHMBXlFJ/AOA8AH8lImdY9rkIwGnZP2sA/CMAiMgpAG4F8HEAHwNwq4icHNC5U0B0yjOt6+2uGb27YM2cCDCuEsgoQX+mERvUGpy9co39iwdZ6mjtzpk6Baipy9/HKTBwKSUN0+olzdh06ZlobkhB4KELabWz6bKaV1pLRERERJNcM3RKqVcBvJr973dE5NcAmgE8a9rtMwC+r5RSAJ4QkQYR+X0AnwTwiFLqTQAQkUcAfArAjwJ9F+SLTnmmdb1dkwzZHjMhCh85/gP7Y5lLLJ3GnnssdXTrzum5c6VueWfAvGZTpw2dzCwRERHRNKa1hk5E5gNYAuDfLQ81AzDXq/Vntzlttzv2GhjZPcybN0/ntCgAXgMK67q6QdWIFpugLjGzBS93rSw8gLXE0omHUsedBwfQd98duAc/RtMJQxgcacRt910B4Lqp96ITGDCIICIiIqKY8dzlUkROBPBTADcqpd62PmzzFFVke+FGpbYrpVqVUq2zZ8/2elpUZtZ1dZvHOzCiPJY1At6GhXssdXx693ZslO1oSQwhIUBLYggbZTue3r3d9blEjjjUnIiIiGLEU0AnIkkYwdwPlFL32uzSD2Cu6ecWAINFtlNMWdfb9WbasUGtwUjq9+FpvZNDKaUCkFGCQTTi5rG/xIIffgBt3XvsZ+FlXTN6N+plNG9bvYzimtG7dd9W8PwEBQwoKqeC8wiJiIiISuGly6UA+C6AXyulvumwWy+AL4nIj2E0QDmmlHpVRB4C8HVTI5QLAdwcwHlThditt2tfcR3ql/yd43PM69wen9GIOXijYJ+BTCPaR7flb8sOODe/rllT4qjt6zltL+B1fZ0ut86dYT2X/CvWpIfXn4iIiCLIyxq6NgB/AuAZEXk6u+2rAOYBgFLqTgAPwBhZ8BsYYwv+Z/axN0XkbwHsyz5vY65BCsWXTgOPXFfMXCOVr49+Dt9I7kDKlFkbUXXYPG5/s5wbcG73esdTc1CfftV+u9uJhRk4+QkKGFBUFoeaExERUcx46XLZB/u1cOZ9FIC/cnjsewC+V9LZUSwUdppcmJfJM3fF7M20A2PATcke/D6OYlDNwubxDmO7A6fB5/UXbcT4ruvzxiaM18xA/UUeRh6EGTj5CQoYUFQWh5oTERFRzGh1uSSysmbgrGWSg8NprEr0YX1tD5pkCIOqEZvHO9D2/rZih83jNOAcizuML7CpbLLWa9lkmIGTn6CAAUVlcag5ERERxYznLpdEdqwZOGCqTBIArj7xSXQnd+R1ouxO7sCqRJ/t8VYl+tBXdwNeOuFK9NXdgMvqfmk74HzS4g5g7WGga9j422t2zSlACiJw8jOkvIIDzgkcau6EjXqCxetJREQBYkBHvjiVQ+a2r0/eY9uJcn1t4Q3MZxJ9+EZdYfC3umZv8CceZuDkJyhgQFF51l8SANP75pudP4PF60lERAFjySX50tSQwoBNUJcrk6xPv2b/PMnvRNnckMK3TrgfOJYf/NVOHA+nIUjueGF0ucwdX+dYYXXcrBaVuj7sOspGPUHj9SQiooAxoCNf1q1YmLeGDgBSyZqpMkmHNWGDalbh/rvK3BBEN+gKC4OG4ip5far15lsnQGajnmDxehIRUcBYckm+rF7SjE2XnonmhhQERqZt06VnTo0ZsCltHK+ZgR11VxXuH+a6tigrFjRQMNen1DVL1XjzrVvyN13/XYaF15OIiALGDB35VnQunU1pY+3yDeha3IEu677TtcNgNQYNQfJ7ffxk+Px2HY1iKa1u1nG6/rsMi931TCSB0feMXzhE5XtCRESxwYCOwue1tNHDurZiM++8PK6l2M14kDfqLkHDvt7vYO5TW3CqegOvy2wcOWcdlq66trTXihKv19BvUOWnbNJPMBPVUlrdADns9abTjfV6pk4GRt8F0m8a26PyPSEiotgQYyZ4tLS2tqr9+/dX+jQoYqwz7wBj/V2uZNPtcS/HzwWDV5/4JG5Rd+YNLUcyZXScBOxv8kvtRmm98Tcdb98rb2HRgVuQMnUKTas6HD73a/EO6oq854JrqLOvna4GAHb/OydGJ0sv51pKMLN1kUMgOneqe2YlRPW8pit+HkRE5EBEDiilWt324xo6ig23mXdujxeTCwYHhtNQAK4ZvTs/mAOmsjpBr+l6dCNw1pW2owrmPrUlL5gDgJSMYu5TW7y/ltPrVrIFv8419DvKwe+apVJnHUa1lJazDqMlqt8TIiKKDZZcUmy4zbxze9zKnJFLiGDClK1ukiH7kyh2k3XsiLc1MHaleL/6oW2Qcqp6A5DCQ5yqHM6vmLBLAMPsnOinI2ml1oD5LRUNC0sooyWq3xMiIooNZugoNnKz7Zy2uz1uzk6NfON09N13x2RGbsJSejyoGu1PYmaLy42Wh66BGtmp12W27SFeF4fzKybMbppR7pzoluELK2sZ5UxYqVlHCl6UvydERBQLDOgoNtatWIhUsiZvm3nmXdHHLQFHffpVbJTtWJXos32tzeMdGFF1+RtzN1l2N2BWxQIljezUkXPWIW05j7Sqw5Fz1hV/fZ+vq003WFy+AeM1M/I2jdfMKP0m1i0ocwpgdANRHX5LRWl64PeEiIh8YsklRZq1a+Ufn9uMnz/3hm0Xy9zftl0utxYGHPUyivW1PegdbS943d5MO+pUAhvrf4r69GsFZWn7Xnkr23lyCCLKrirSOVByKbHKf8+n4csf6sR//69/xKlqCK9LI46cW2KXyzBLuzSDxZ0TbegbuwY34sdokqMYVLNwW+YKtE+0YbXua/spJQ17cHhUhtdTtPF7QkREPrDLJUWW366VeRw6HWaU4MPv/2Dy5xoRZJQqOvLAel59dTegJWGzps2pS12Rro07J9qCe88ar1tyd87cOixJAGqicB+Ha9DWvQcDNmsbmxtS2Nu5TO88/HQJrFQHTKJi+L0iIiKwyyVVAT9dKws4ZKEG1azJ/04la/APHWfh5e6V2Nu5rDCAypb1rdr1UTwifzVZrlm0PNNOkRKrQN+zxutqs5Yq2gVzRa6BbgObovyUkvpZyxdmuWbURaVbajWazt8rIiIqCUsuKbICvem36XQ4XjMDO2qvgozCfQi5KbuVANCSGEJ3cgcwZpRnYgxYX9uDlsRRYGYL9n3ketz4QCMGf7jb/tgOJVaBvOdiv90PqrTLrlQRAKQGUBnXrEJTQ8o2Q+fU2KYoP6Wkfjpghl2uGVVRHZheLabr94qIiErGgI4iK9CbfptW7bXLN6BrcQe6HJ5iXsv2+IyvYg6c1+D1ZtpxoP4C7O1cZirJNPYfGE7j5nufAQDXsknf77lcN9tO2S+V8VSquG7FQtvS0lyDGy1+gjI/Lfyn6/wwBhzhmq7fKyIiKhkDOoqsQG/6YTTi2PL+NgweT6NpRgrrJhY6NuCwrpNzmgfXJEcBAMmEYGR0HAs6dxfMtAOmyibdArqS3rPbWrYwbrZ9Nlgp2sBGl9+5aqVmLafr/DAGHOGart8rIiIqGQM6iqwgb/qtAZpb1sy6lm1QNaLFZtj4oJqFhlQS742O462RMQCFM+0m9/VQNqn9nq0ZObu1bEDwN9tesmIujR1WL2n23+glpxJdAis1sDzHen1PuxB44eHwG2noBhxs8KGn0t8rIiKKHQZ0FGlB3fQXazZid3xr8LV5vAPdyR2ol9HJbeM1M9By6SZ84IFaDKfHXM/Ba9mk1nt2WstmFfTNtltWrMzrrKzjLUrO9unwmxn0w+767v/u1ONhXm+dgIPr7fRV8ntFRESx5BrQicj3AFwM4HWl1CKbx9cB+ILpeH8AYLZS6k0ReQXAOwAmAIx7abtJFAbdZiPWtWzmxifWuWmDw0+7vr6fUtGivGTewrrZLpYVK+M6K7vsa999d+DCh+1nCAaqUvPDvATyYa1r0wk4uN6uNJxLR0REGrxk6O4C8G0A37d7UCm1BcAWABCRSwCsVUq9adrlfKWUzZAuovLRbTZit5atN9NeMIT88Yeedzy2l5l2vjmVv3npNhnmzXYp66xKzBZas6+rEn3YKDtQn85mU6sxK+S1hDasdW1eAw6utyMiIgqda0CnlPqFiMz3eLzPA/iRnxMiCoNusxHrWjb7VXFGhm/r5WeHNwzcjVP5m5f5co4320eM+WJ+MlulrLPSyBaaSyytn8362p680lgA1ZcVcrq+dvtVEht8EBERhS6wweIiUg/gUwB+atqsADwsIgdEZE1Qr0Wka/WSZmy69Ew0N6QgAJobUq4B1+olzdjbuQwvd69Es0Mmr6khVdKxdx4cQFv3Hizo3I227j3YeXCgtDdmMyx835l/g7YHGt2PXfSm2udA4+UbjMDSrFhjh2LZQotcieWAQ6DdZNO8BkA8skJeB3bbXV+rKDTS0P0eEBERkbYgm6JcAmCvpdyyTSk1KCKnAnhERJ5TSv3C7snZgG8NAMybNy/A0yIy+Gmw4pbh0zm2bsdNV6byN60ZeHbZPatSM1u6jR00SvPsGtyYOXUkjXxWSCdLaXd9y9XlUgcbfBAREYVOlEOL9bydjJLLn9k1RTHtcx+Af1FK/dDh8S4A7yql/t7t9VpbW9X+/ftdz4uonILqpNjWvcd2zV1zQwp7O5f5OkftY5vXrTkWlgJG9i/Em/GtixxK8+YCaw/nbVrQuRuXJPqyDWqGMKgasXm8A72ZdgiAq098EreoO1E7cXzqSV7LUCvJ7Rqw/T8REdG0IiIHvDSVDCRDJyIzAfwRgKtM2z4AIKGUeif73xcCKKyfIoqJoEYo6HbcDPXY5uYWTgEFgLwSzNzzgqTRCv/qE5/E+rGpERItMoTu5A6ckqxD1y1/A2AlcOij8Qt+imUp2f6fiIiIHLiuoRORHwF4HMBCEekXkb8QkS+KyBdNu30WwMNKqfdM234PQJ+I/ArAkwB2K6X+b5AnTxRHTp01vc6pK+XYCRH3NXVe1mU5rGvzzWYtoFNGbX3ynoKmJ/UyivXJe/KPt/Yw0DVs/B3RoMe8lvI1NNrvNLNFa40hBcTrekYiIqIKcw3olFKfV0r9vlIqqZRqUUp9Vyl1p1LqTtM+dymlrrA87yWl1FnZPx9VSv1dGG+AKG7WrViIVLImb1tQc+rsjr0q0Yd/TV6PF0+4EveM/CX67rvDPqizBlVOQmousnOiDW3vb8OC4z9A2/vbsHOizXa/+vRrWtujytrc5eujn0Na1eXvlMtSRrn9fzUGPrmM6LEj8N0giIiIKGSBdbkkoiJMN72rH1uB7y/9rVZXTLNiHTLdEGSwAAAgAElEQVStHTdX1+xFd3IHWhJDSAjQkhjCRtmOp3dvtz+4ObM1c679PiE0F7EGN7lmLraBp9PrR6HpiUZwY23u0ptpx01j1+A1zEZBljKq77laAx9mRImIKEY8NUUpNzZFoapyqAfju67Pa9IxXjMDtZ+5XbsU0NohEyg+865/w0fQkijs+NifaUTLxhddz7vkGXdOx3NY16bVzCXo8wqK5nkt6Nxt24ZGALzcvdLXsctGo5lNrHQ1wL5JkBi/7CAiIioDr01RmKEjCtnIgxvyOy4CqJ04jpEH9Wdx2bXsT49NYMtDz9vu35Q4qrU9j8a6NlcumRytZi5BnleQNLM6Wmspg3jPYZRGRrkU1I+oZkSJiIhsBDmHjohszHBY2+W0vRjdLpbHU3NQn37VfruXFzR3wfSjWLCzuANNDSnbDJ1jo5igzitImsGN22zDAn7ec1hdMme2OGToAgp8KjWqQaPrKhERUaUxQ0cUssHMLK3txeh2yKy/aCPGa2bkbRuvmYH6i8q8Fsgl2AmzUUzZaGZ1rOsddddSatHMHhZbp5nHrjNqUIFPJdfn2WVEz7rSuF7V1PyFiIiqAjN0RCHbUXcV1o/dkddqf0TVYUfdVejSPFYpWZ1aIC/LUVuJmWwumZxcEOM0uD2ooe6hKiGrE9RsQ1ca2UPrOs1cgxoAheea+x6FkUVzyeqGzpwR5RxAIiKKMDZFIQrZzoMD6LvvDtyIH6NJjmJQzcJtuALtn72upJt5a3Bz/umz8fPn3oh2sOOjqYduI5iKcisRrFQJoUbzEq0GNWGKUmOSam3+QkREkea1KQozdEQhM4KO63D5Q8sDCbrMWR2tbEoJAsuM+cjkFGsEE7mArtg6t0pmeTSyh7rrNEPjlNWVhBHslTMgrtbmL0REVBUY0BGVQVildbrBjk6AFniwWGJTjyACjEqVbJpf9/EZX8UcVKiEUCOg1m5QExa7IBQAVPb7Xs6AOOzmLxRdlcqqExFpYEBHFGM6wY5ugBZ0sFhqUOU3wAg7i+n1dU9VbxhD5qzKleXxGFBrr9MMizUIlcRUMJdTroCYXS+nJ66dJKKYYJdLohjT6XqpO8OulGBxYDgNhamgKdcd0e3xYvx2wNR93648znOzvu6garQ/XsSyPGXtvulmcYexRq1rGFAZ+33KERBHdfYhhUuzOywRUaUwQ0cUYzrZFKcAbWA4jQWduwuyZjqZMbdsnp91cG4dMN0EuiZM4zf21uNvHu9Ad3JHXrfT8ZoZRtfRiClb901oZG4rXfYYxdmHFC6unSSimGBARxRjOsGOU4AGIC9rljtuEMFibrvfoEo3wDAHCQkRTNh08y1pTZhGK33r9e7NtANjwPranslup/+aWYLPPrgB9feuqez6nAqtE9Iqh2XZI5VbpX+JQETkEQM6opjzGuzYBWhW5qyZzmw4t6CpnI02rEGC9bxWJfpwU7IHTcePAlvdgxfz+3xxRr99nbrNb+ztrndvph29o+2T59Gd3IH6dDZjV6n1ORVcJ6SVuQ1z5h2RHf4SgYhiggEd0TRhDdCcJlCas2ZOwaJb0ATkZ/PK2WjDLkgAgBoRXCz/hu667yKF942NLsGL9X0OZmahJTFU+KI2v7F3u97ra3vyyi8BaDX5CKxzZwUHeGtnbln2OH1Eobskf4lARDHBgI5oGjEHaE4DpL1kzYoFTRmlCgIMv+vgdDgFAxml8K1T7weOvZ//QJHgxfo+7dbBpVUdDn/keiy1ec1i17tJbAJDwNP6HE+lil5viCu4TigyIxLIvyADsCh1l+QvEYgoBtjlkmia8tM9sljQ9HL3SuztXFYQrK1e0oy9ncscHw9K0c6fmsGL9X32ZtrROXYN+jONyChBf6YRN41dgxufPc31vKzX20/XS9fOnbkb4mNHAKipG2K7jpxOr1eGdUJ+O5i68tiRlHzS+b55we6SRERaGNARxU1AN6mltKffeXAAbd17HMs1o5BZKRokaAYvdu+nN9OO9tFt+PD7P0D76Db0ZtonA7/c9VnQuRtt3XvyxjJYr/eOuqswXjMj/+Dm9TlFPmfXUkWdG+LlG4zXdTqPEIU6IiHoICOqohC0Bh2AsbskEZEWllwSxUnApUg63SOtZX5WFRk+baNoeWeNXpMDL41kACPw81IGmX+9VwKHPmpfpubyObuWKurcEC/uwL5X3sLcp7bgVDWE16URR85ch6VlKjMLbURCBdcGlk1UShODDsD8dpeMwvo7IqIyYkBHFCcVvEl1WjcHGJmVsNbElcIxSNBscmANDmemknhvdBxjE1M5ylwgW9KsPaf1OS6fs2uTGY0b4p0HB3Dzvg8hPfatqWPtq8GmuQOR+TxLMh2yPFEJWoNu7++nu6TfIJfBIBHFEAM6ojip4E2qU5mfANjbuSz01w+MZpMDa3Do1F1y7T1P2z6/pAHmLp+za5MZjRtiP0PfI206zBCLStAadHt/P90l/QS5Ucl4EhFpYkBHFCcVvEllR0KDU/Yv0Ovj4XMuWqqocUPsd+h7ZNkFGYkkMPqesd6sGrIvUQlaw2jvX2p3ST9BblQynkREmlyboojI90TkdRE57PD4J0XkmIg8nf2zwfTYp0TkeRH5jYh0BnniRNNSBRtYhN6RMOYCvT5BfM6LO4C1h4GuYeNvhxvSol1Bs4o1e4msxR3AJduAmXMBCJA6BRAB0m+iapqk2H1PzEFrOZukePy+BaJYIxg/XVujkvEkItLkpcvlXQA+5bLPvymlzs7+2QgAIlID4P8AuAjAGQA+LyJn+DlZomnPepM6c67xc0A3T25dGr+/9Ld4YsaX8dIJV+KJGV/G95f+Nt5leQEKtGNjyJ+zmVsgmmv2MpAdjp5r9hKboC4XZNR9AJhwGOQeV9MhaLVy617q55chFRzhQUTkhyjl1IDctJPIfAA/U0otsnnskwD+Wil1sWX7HwLoUkqtyP58MwAopTa5vV5ra6vav3+/h9MnoqDYdbFMJWumghLr+hLAuFEKKdCg8nFaFwg4D6BvbkjFa+1kVwNgO3BDjIAvSJVqrLF1kUMJ5lwjsK0GXt5jqdef/xtHRBEjIgeUUq1u+wW1hu4PReRXAAZhBHf/AaAZgPl/dfsBfNzpACKyBsAaAJg3b15Ap0VEXrk2x9BcX1IsSKBoKbYeL85r7MzfwcdnNGIO3ijcKejsSyUba0yHkkEv77HU9XdhrAUkIiqDIAaLPwXgQ0qpswDcDmBndrvY7OuYDlRKbVdKtSqlWmfPnh3AaRGRDtcbd42bxViX6VEeL2vsosj6Hfz66OeQVnX5O/lZf+q0jivoIds6pkPJYNjvsZxrAYmIAuI7oFNKva2Uejf73w8ASIpII4yM3FzTri0wMnhEFEGuN+4aN1LFsn2VFssGHxUU12Y41u9gb6YdN41dg9cwG77XJRZbx1XJLFkFmyaVzXR4j0REmnwHdCIyR0Qk+98fyx7zKIB9AE4TkQUiUgfgCgC9fl+PiMLheuOucSMV1TI9Zg71aTd7KdaBsIzsvmu9mXb84fFv+c++FMvCVTJLVsZmOhUzHd4jEZEm1zV0IvIjAJ8E0Cgi/QBuBZAEAKXUnQAuA/C/RGQcQBrAFcrotDIuIl8C8BCAGgDfy66tI6IIch1WrbG+JKoz65wyh1/p+RXW3vM0mhpSOP/02fj5c2/Efu1fkGsYi868M4vQYOZQv4PFsnCXbg92yLauUtePxcl0eI9ERBo8dbksN3a5JIo3146ZFbKgc7fzQl4HUThvL8wB3MxUEu+NjmNsYurdluV9RKjLYqjfQbf3Wakul37F9bzjitebiFyUu8slEdEk12xfhThlbYrJ6/RpEWYnT51jW4OX4fSY1vsITBDrx3RucovsG+p3cPmG4lm4OGaQIpRdnRZ4vYkoQMzQEdG0YZe18UIAvNy90vVYQWWAdI/tNCvOyu59BMpvhk5nDlilZ4ZVW3allM+u2q5BOUUom01E0cUMHRGRhTVrkxDBhIdfatmtu3Kd21eCXFbOLjgrdmyvzWY8rx8r9UbdLXPlRmfWoeZcRCvf2dU4ZuGK0c2uljPDVI2BY5xmBlbj9SeqMgzoiGhaMTf48JKxc2rRH3QnTy/n4nRsL6Wk5vdRNJjxc6PudzCzzk2ujxti67XOdTsFUPGy4IqZ2eKQMXLozukzoPasWksTda93pVTr9SeqMkEMFiciiiW7lvxXnTfPU4v+oAdu22X8vB7bbuREMiE4uT5Z8D5cRzf4HYztZzCzTst/p30l4ToyIcpzEitGd75b0BmmKA5qD1Nc5ulV6/UnqjLM0BHRtOa5Jb/FuhULbde5lTpw2y2zV+zYOg1AXEtFKz0Y22vJpt2+AKCy761IJiGqcxI9CbL8zXqss64EXnjY27GDzDAVywLFqTTRqthnpZvNrlTZY5yvP9E0woCOiKgEQXdRLFY22ezh2F4DU9dgppKlYDo3udZ9JTEVzOU4lABGdU6iqyDL3+yO9asfem8q43e9pJnboPY4lCYC+UFX6mRg9F1gYtR4zO6z8roOs5Jlj3G6/kTTGLtcEhFFgFtny6BGJDh1xGxuSGFv57LKd48sVVcDYDtlUIzyT+Q3nflMog/ranvQJEMYVI24DVeg/bPXRXsNXZCdEYM4VlBZo2KfndOg9qh9H+3+3dip1GdVqrj+74EdNnehGGKXSyKiGCmW8QuyiYdrqajfxiYuQpvd55JJMF/DVYk+bEruQL0Y2ZMWGUJ3zQ7U1pwFoCPc8/QjyPK3II4VVKfPYp9dyN/HwNhlGe1U6rMqVVyuvxs2d6Eqx4COiCInkjfTZeBUNhnkiARPpaIhteT3EpiW/Nm7lACar+H62p7JYC6nduL4ZHmmbgBdtu9rkOVvUSqlC3tQezkyM16Dqzh+VtUwoqNcXVmJKoQBHRFFClvKFwq6iUepjWD8sgtML5j4V5y360vAriGMpOag770/xsDoJwBofvYumQTztWqSIftjZG/KdQJoT9/XoAKKINetBXksv8LMApUrM+MUdJlVw2cVV2zuQlWOAR0RRUoYA7vjLk5NPIplq6wB6KpEH7qTO1API1tWn34VG2U7RhMZ9GbaAWh+9kUyCeZrOKga0WIX1GUzHjoBtOv3NciAIsjAJ2qldGFlgcqVmbELuhJJ4IQPAum3Sru+1iYrtanSjzXdVTrLSRQyBnREFCmxbikfkqBHJITFLVtlDUztSh/rZRTra3vQO9o+uS2Iz958DTePdxiBpPm1TRkPnQDa9fsadEChG/i4tc6v9qCgXJmZoANk6y8C0m8a39FLt1f/ZxYGZjmpyjGgI6JIiVM2qlyCHpEQFqds1Vd6foW19zyNmakkPlu7F19J3IMmGYI4HKdJjub/HMBnb76G9w+345RkHdYn70F9+rWCm2+dANr1+1rJUi82gihvZibIANnvLwJ8lPlW5RrmqGWkiQLGgI6IIiUu2ahyq9S6Nx1O2aqJ7Hic//7+z/F31syY3XHUrMn/DvKzz7+GKwH8zdSDh3qy7eH7sXpmC5qXXo8bnz3N9abW9fvqN6Dws/6OjSDCz8zofD46+/r5RYCPQL6q1zBPh4w0TVsM6IgoUuKSjaJCxYajA/YlllbjNTOwo/YqyCjK99nb3AAvfeZW7PUwa8v1+7p8A8Z3XW900cwar5mBWi8Bhd8MGxtBRKfhiu5nqfuLAHOwKAlA5WfKvQbyXMNMFE8M6IgocuKQjSKDuTxrZiqJZI1gbMJuSHSR7pIAAAFmtqB2+QZ0Le5AVyhn66CETJb5fV994pN4JHkP6me8BpzQAtRswOQ8u4k29I1dgxvxYzTJUQyqWbgtcwXaJ9qwOoTzyqMZFFRlqR0QjYYrup+lTmbRGixag7kcD4E81zATxRMDOiIiKom1PGs4PYZkQnByfRLDI2NIiEyWWwLFukvOBdYeDuR8SgpINDNZ1iHl68d2oH48m3m0ZF62PPQ8BkY/gZ/gE3nHeNxLxsNvhk0jKCh3qV0lg0frLyFEgOGRMf3z0Pl8dD9Lncyi16HmHsp8uYaZKJ4SlT4BIiKKJ7vyrLGMQn1dLV7uXol/6DgLqWTN5GObxzuQVnX5BwloPVMuIBkYTkNhKiDZeXDA9bkjqTla292GlE9mXuAz4+F0A+51/d3iDuCSbUbADDH+digjLVZqFzQ/n5Wt3PrHrgbj70M9nl97OD2Gt0bGSjsPh8+hPzMLbd178o9Tyme5uMP4RUfXsPG37no7M4//ztatWJj3bxbgGmaiOGBAR0REJXELVlYvacamS89Ec0MKAuDASRfg8Llf8xRg6PITkGweuxwjlkBzRNVh89jltvvrDCl3ymx4yngs32DciJvpBsBFgoKdBwfQ1r0HCzp3O659DKPULtDgMVdueOwIADWVIXUI6uxeu+TzsPl8RlQdNo93FAaHQXyWTpyCQqmB7r8z67/Z5oYUNl16ZvGspUZATVWEn3uksOSSiIhK4qU8q3A95DIA1wZ+Ln4yYf/87sfwZsKYf5db57Z5vAP3v/8x27V8OkPKfXVtDbGhh7XE0kkYpXaBrtPSXJtmN9ze+NyHMKgajc99uL3gebZMn0/mWD8GM8b3pjdjPD+vmUiYzVmcSmtL/GWJ1hpmjsaYnvi5R45rQCci3wNwMYDXlVKLbB7/AoCbsj++C+B/KaV+lX3sFQDvAJgAMK6Uag3ovImISEMYa5aiNGLCz9qfpoYUeofb84aZA0Z2wo7OkHLfXVsDbuiR+x4U60aaE9ZnGeQ6LXWs33aeodP2poYUzn37kckgDgAS2R1bZAjdyR04JVkHY6yFB9nP5yOdu2HXCigvgAyrOUslZ6xxNMb0xM89crxk6O4C8G0A33d4/GUAf6SUektELgKwHcDHTY+fr5Qq1tqMiIhCFHTDC2tTiRnJRGlNJTRep6khhfNPn42fP/eGbWDkJ7jUfa7OkPLc/lHoFuk1KydwGBnhZyaeSZC/CPgdGjEHbzhsL3TbGS9g0YEdSDmMz6iXUaxP3oO8GYUeVLyZiJ9g0fq5nnYh8MLD4c/Lo/ji5x45rgGdUuoXIjK/yOO/NP34BACPq7WJiKgcgpwtZdfZMpWswdbLzw40aLELQu9+4r8mH7cGpX4yYaU8t+iQ8ohyWz8GGFnJvZ3LCh8IsMQqyFmTm0Y/h02WDOmIqsOmsc/hWzb7L33xdsBlFmJ9+jXt84hStlqL3ee6/7tTjwc9L4+qAz/3yAl6Dd1fAHjQ9LMC8LCIKADfUUptd3qiiKwBsAYA5s2bF/BpERFNX0GuWSrX4GEvwYf1df1kwqKSRQuT2+ddNAAJuMQqqOu9/6QL0Pk2CtY/HjjpAvsneMkglHBTGmSQWlZeRh4ENS8vTgLKRletav3cYyywgE5EzocR0JkXIbQppQZF5FQAj4jIc0qpX9g9PxvsbQeA1tZW+6m0RESkLchysHINHvZ6vGoYeFyumWxO3wPAyMwVLbG0XSGGipdYGZmx0bz1j6lkDTY5BaZOmYUcHzelsfylgNfPL4h5eXHBhh/uqvFzj7lAAjoRWQxgB4CLlFJHc9uVUoPZv18XkfsAfAyAbUBHREThCLIcrFxrhYoFH2G+brn5Xd+oEww6fQ9s29Jbb2qdVLjESjszZpdZgABQRnv/St6UViIr5BbgmvdzElazF59K/kUJG354E9HPfbryHdCJyDwA9wL4E6XUf5q2fwBAQin1Tva/LwSw0e/rERGRniDLwcq1VsjudayiukZJ50bSTwmrbjCo9T3wUoqnk80KMVjRyoxFKLNg/p5cfeKTuEXdidqJ48aD5coK2Qa4FjEspfP1ixI2/KAYEqWKVzeKyI8AfBJAI4DfAbgVQBIAlFJ3isgOAH8M4LfZp4wrpVpF5MMA7stuqwXwQ6XU33k5qdbWVrV//37Nt0JEROVQrhJBnS6XYfP6nu06STpmwQAscGh3LwBe7i7eOr+te49tFtOxsYmOrgY4lllC3AMhcwCXOhkYfReYsIx2CGiofBxZvyd9dTegJWE3z3CuMRA+TH66XEaUr38bWxc5NPwow2dBZCEiB7yMffPS5fLzLo9fA+Aam+0vATjL7fhERBQv5VorFJU1STq/7dfNuPkpYS1pPaPXTJljFzsPN7XWcs30m4X7TPMSNuv3pMluOD1QnqxQFZbO+Vrry4YfFEOJSp8AERFRlBUL0qy83EjuPDiAtu49WNC5G++9P45kTf4IbK+lpE5Bn2MwmAu0jh0BoKbK+g71FO67fINxE2vm9abWS7kmMK1L2Kzfk0HVaL9jSGsUzd/Btu492HlwIJTXqRTtfxtmizuM7PHMuTCy0XOndTaZ4oEBHRERURE6v+13u5HMZfsGhtNQMOb4QQEn1ychMErCnMozrdatWIhUsiZvW8mjB6z83NR6DdSm8cwq6/dk83gHRlRd/k4hZYWs38FcxrmagjrtfxtWizuMTHTXsPE3gzmKuKDn0BEREVUVnbJIt6Yxdtm+sYxCfV0tDm64UOu8tJvd6DZ7KLUUz0vnxGlewmb9nvRm2lGnEthY/1NjsHmIa9fKNUuykmI7F5CoRAzoiIiIitDp7Ol2Ixn0HD+tdYaO6+ICzpTZrUFKJIETPgik34ptow0AgXXrtPuetK+4DvVLPPWO86VcsyQrLSprcANVLQPPdd9HtbzvEDGgIyIiKkL3t/3FbiS9ZPtC6yJarmYPJYwGCPI9h3b9Ah44XamAo1yzJCuu2oKAahl4rvs+quV9h8x1bEElcGwBERFVI7exBrpjD7y8njm4ue2MF7D0xds93eSWczxFUO856OuXp0ra2Yd6jaLCGgQAFRuVEdi/oyr5/mm/D839y/W/W+XidWwBm6IQERGVyeolzdh06ZlobkjZNkHR6ajpxq75xZ/u+xB2fvIh12YPXhpnBNUpMcj3HOSxClTJwGm372BV0GkAFKJAG9CE8f071GMETF0Nxt92HW+Dpvs+NLZPh4Y/TlhySUREVEbFSu2CXN/kp/mF23N1ZvMBxX9rHuR7DnV9WLnWIJZBVa4vM4tI8B1oA5qgv3+VKmXUfR8a+0+Hhj9OmKEjIiKKCF/zsyz8BDduz9XJhLn91jzI9xzksQr4mc1H4TNnm8Th9rbMwbenf4Nes2RBf/8qlcXUfR8a+0+Xhj92GNARERFFhN38LIERBLV178EtO5/xXOboJ7hxe67OjZNb8Od7ZphJkMcqwIHT0ZXLNh07AkABaqJwnwoE367/Bq3nncuS2QV1QX//HLOYR8Itv9R9Hxr7h/oLnYhjySUREVFEmNfSDQynIQByrcsGhtO4+4n/mtzXrcxRZ9yC7nN1OiW6BX9BzgwLff5YqbP5glYtHRyDeh922SYAkBpAZSp2jVz/DTplye77InDvmsLzDvL7V2xeZNjll7rvw+P+fv43L+7Y5ZKIiCiC2rr32AZNVs0NKeztXGb7mJ+Ob8Weq9Mp0e59rEr04at1/4I5GIpMt83YiFAHR19s3sd4zQx8Tb6If373Y3qfdVcDpn71YSZGA6AKKvr9dTxvk7A+W7vvkVXcOmii+v73wmuXSwZ0REREEbSgc7fbrR4AoyTz5e6VYZ9OAa83Ttbgb1WiD99I7kBKRqd2crhpnRYt9nVVefv6/kwj2ke3AdD4rON6TZzO2yqs9zGZIXU6h8oHxNOd14COJZdEREQR5FTWaLdfOdgFcE6ZQTNrGeRX6/4FKYzm75RrxpAN6HKvZff+p0vXOkdBdHCsVMmm+XUdfl3RJEcn/9vzZ718g33WMuoNa+zO205Y3TlzpYyOAXH8OrhOV2yKQkREFEF2DT6syrU+RHe+k3VGHQDs7VyGl7tXGmWWdrI3rebXcjIdutY5Ktbe3QudRhxBsr6ug0E1K/9nL591XBvWWM9bHP69hx1YsYNr7DFDR0REsVRtayWs7Bp8nH/6bPz8uTfK/p515ju5zqhzmStl91pWlcxKlnq9AztWKdkoc2ZMEoVdIC0Z0lA4NS4xGVF12Dyefw6eP+uoNKzRZT5vp/WRYQdWudevhkY70xQDOiIiih3dwdZxFZUB0EGNKVi9pNk1IHHLyJQ7KxnEd8zLsTwHfLo339Ygwa6lPxD+0G2H4ysASglek1nYMnE5ejNtk48V+6yr8hc6lQys4hoQEwAGdEREFEM6GSPyL8gxBW43rcXWDjZHNCvp91jawaPOzbeHzBiA8Mv6HDKzA6YmKMmE4OT6WgyPjKGpIYXbzngBSx/7a2BXP5A62XhC+i2MpOag770/xsDoJ4xjlBBsRzYgnAaBVWSvfYxxDR0REcWOTsZoOrGuXSs2eFyHzsBuT8N9F3cYXfu6ho2/TTewTq912+VnY2/nsrLd+AX5HXM7ltvwdTdFP3cPmbc0TsCX37gk0O9MAZt1WtYSy7GMQn1dLV7uXom9nx7C0mdunVpzl37T+AOF+vSr2CjbsSrRN/UeNK+XdU3o2nuexvyA/91QId31uOQNAzoiIoodT0HDNBPmjdLqJc3YdOmZaG5IQWBkypzayesEf35fK0xO36WEiHbA7PZ99RM8un7uTpk3qYGCYEA14qbRv8CuTHu4N9eWBiD9mUZ0jl2D3kx73m6T79kls1gvo1hfm9/IxWuwbRdA59q0MMAIl99fXpA9llwSEVHsrFux0HY+WTnWVkVV2GWoXtfz2TVz0S2pisLaQbvvGABMZOf36pT5uX1fdUparUpes3jJNrQ/0FjwutbvTKDlcaZywsttBs4DpvfsIbNoHnGQ91wXboFfwb+bSo15iKsi14vVFeHwlKETke+JyOsiYjvVUAzbROQ3InJIRM4xPXa1iLyQ/XN1UCdORETTV1SyOFESpRul1UuaJ8cUlLNMMkjW71iNSME+XjMLbt9XP1lNT2sWHVr6uz03zKyv63v2sKbPPOJA5xc6XgK/yWtTqTEPceVyvVhdEQ6vGbq7ANEfF8IAACAASURBVHwbwPcdHr8IwGnZPx8H8I8APi4ipwC4FUArjGz2ARHpVUq95eekiYiIopDFiRI/WR6yZ/6OLejcbbuP14C52PfVT1bT0+fu0GjD7blesr6lZvBc37PL0O3xmhnYUXsVZBTamUOn7KvZ5PWzK/0sx5iHuHK5XoFXVzB7CsBjQKeU+oWIzC+yy2cAfF8ppQA8ISINIvL7AD4J4BGl1JsAICKPAPgUgB/5OWkiIiLKxzLUcIUdMFsDvlyjE7dAyc/n7vZcrxm8Ukc7FAS5h3qAraab87OuBF542PjZ1OUSM1tQu3wDuhZ3oMv1VexfFzCCyYHhNAT5o87zrp9T6WfYYx7iyuV6BVGSPck6kuPYEWDndcCDN01+T6ZLgBfUGrpmAOZetP3ZbU7bC4jIGgBrAGDevHkBnRYREdH0EOiNkqbp0Ia8nAGzW6Bkvd5/fG5zSQPn3b4zuhm8VYk+rJceNO06CjymeTNtd3P+qx9OlocGzRxMFv3+OoxbKHXMg/a/lbhloDxcr8CqK+yygZmxbDdUTJV7AtG+ZgEIKqArLCw3ftnhtL1wo1LbAWwHgNbWVtt9iIiIyFklylCjPuRd5wa62L7lDJjdOgFar/dPDwyUvIa02HdGJ4O3KtGH7uQO1MuosUH3ZrqCpY1F/904NZVZvkH7dbT/rdgFuZUKULwGlgFeL1desqTTpDw2qLEF/QDmmn5uATBYZDsRERFVgSi3Iddp6uFlX2uzFwCO89/8zAQsVupYzuvt1szFXG66vrZnKpjLyd1Me6Fb2nioB9i6COhqMP4Oq0lJkaYyurQ/u2JBbjnpNIYJ8Hq58polnQblsUFl6HoBfElEfgyjKcoxpdSrIvIQgK+LSLbwGRcCuDmg1yQiIqIKi1J3TSudUQ66Yx+KZVuAwiyaTtayWKljua+31wxekwzZ7qOO9duWaxXQKW0sd+bK2lQmF0zaZauCbNlfxvV7RTPZutlThyY8gXNpnDOpxPLYOPE6tuBHAB4HsFBE+kXkL0TkiyLyxewuDwB4CcBvAPwTgOsAINsM5W8B7Mv+2ZhrkEJERETxF+U25Do30Lo328UCQL9ZtGIt/aN0vc0ZvEHVaLvP72C/vcDyDUZpnplTqV4lM1fFslUeWvavSvShr+4GvHTCleiruwGrEn3On51TIBJwgOKanfYbWIaVTbVmA1OnADV1+fuEVe4ZMV67XH7e5XEF4K8cHvsegO/pnxoRERFFXZS7a+p0ptTtYllKpkxnxAHgvF4vStc7l8H78lc7sMm8hg7AiKrDprHP4VteDpTL6HhZp1VCgBFY4x63YNLusfu+CNy7BnuSJ0GS76FOxgEALTKEbyR34PAZ8wEsK3wt3fVoJTZQcc1O+2kME3Y21S57GqcmMgEJquSSiIiIpqFKdtd0oxNs6gambgGg3xEHTqWOpVzvcnQh3X/SBeh821hL1yRHMahmYfN4Bw6cdIH3g3gt1dMMMPw27jFfvxdn9NuXtxXLVinjdU8YO1bQLjAlo1j64u0Ari14raaGRtx25t8Yj7sFKF4CJ4dgx/WXE34anZS72U25yj0jhgEdERER+VLO7po6wYlO8KMbKLkFgGFm0XSud9BdSPf1fgdzn9qCU9UbeF1m48g567B01bXZ6zGK3tH2yX1TyRpsCiNzqBlg6K6PNLNev8HMLLQkbNYLSmIycNOWDQbtPqs/3fchbLr0IffPyi1wOtSD8V3Xo3biePY1jxg/A2hqaCz+Cwid7KnDe/O8nUrCgI6IiIhioZTgRCf40d0XKB4ARiFr6SeYsdrX+x0sOnALUjIKCDAHb2DmgVuwD8DqVddOvl7o71kzwPDTSMZ6/TaPd+SPZ8gpNZgDJjOLvj4rl8Bp5MENqM8Fc1m1E8cx8uAGrFvxaMEvIC6r+yU2yk+Brtemru/aw5pvDIHP8SN7DOiIiIgoFoIMToJQLACsxExAO0F2xZz71BYjmDNJySjmPrUFWHVted+zRmmd7vpIM+t16s20A2NGaWlL4mjxzJzUuAd6psyir8/KKXCSBNDVgJT9GGjMGHkNa+95GjNTScxIJjA8MoarT3wSt6gdqE1PZfNKXvdWzrl001hQc+iIiIiIQhXlEQlRYp6BlxD7oQGldMU8Vb3hsN1+ZEFUFOsa6sbuOvVm2nF5/T8BXcOAyjg8U4DP3lnYuTORNLox2sxo89XB1K5LKJANKJXj6IhBNQsKwHB6DMfHMth6+dno+sBPp0ozc0rtIlrOuXTTGDN0REREFAt+Mi1xprNu0FqWOqEKMzOlrud7XWZjDgqDutelEXO0j1Y+uusjzdd7ZiqJZI1gbGLqOuZdv2IlhZqlob46xlpfy8OavhFVh83jU+cyme0+HvC6t2naqKScGNARERFRLER5REJYdNcN2pWlAkCNCDJK+VrbduScdZiZW0OXlVZ1OHLuOtuArhzdNb3yWg5qvd7D6TEkE4KT65MYHhkrfB9uJYUawYzvjrHm1+pqsN1FKSNfl+tC2ptpz3t8cDgN/B7XvcUNAzoiIiKKhSiPSAiL7rpBp/LTjFJ4uXulr3NZuupa7AOyXS6H8Lo04si5RpdLq6C7a5aL3fUeyyjU19Xi4IYLC5/gpwOkjcDWITpkDn8ns/GHx7+FhIht9rapIcV1bzHEgI6IiIhiIyrNRspFd91g2GWpS1ddC2QDuDnZP3ai1sDGq5LWafooKQwti+kQlM255Ot4efHKgoAbMGW7F2eHnE/DAd1xxYCOiIiIKKJ0A7SolKXGtYFNOddpBp3F1BlK7prtdglSo1ROSwzoiIiIiCJLN0CLSllqU0MK5779CNbX9qBJhjCoGrF5vAMHTrqgrOehq5SAuNTgJsgsZilDyUvNdrsFotrX41APs4E+MaAjIiIiiqhSArQolKXedsYLWHRgx2QDlRYZwjeSO3D4jPkAllX03IoppSNmqVm2ILOY5SxxLfZaAPSux6Ge/NJQl5l3QWcGqyXTyICOiIiIKMKiEKDpWvri7YDNEPKlL94OoLCJSpS4XW9zEGDXXMRrIBVkeWc5S1ztjrkq0Yf1Iz1o2nUUrTILmxNTHTSLXo9HN+av8wOmZt5lA7rc9R4YTkOAyRHpQZSoxrFxjx0OFiciIiKiYDnNLCt1lllE5IKAgeE0FOzn/AHeAindgefmgfFt3Xuw8+DA5GO+hpJrsh5zVaIP3ckdaEkMIQGFlsQQupM7sCrRN7mP4/Vw+Z6YrzcwFczlmDODutwyjXHCgI6IiIiIguU0syzms8yc5vxZeQmkVi9pxqZLz0RzQwoCoLkhhU2XnmmbHbIGkrlsUi6o0w0O/bC+1vraHtRbsrH1Mor1tT2TPzteD5fviZfrrZWFPNQDbF0EdDXgnpG/zAs6SzpeRLDkkoiIiIiCVaWzzLzc7OsEUl7Lad3WyJWzGU7Ba8mQ7X5NchSAy/Vw+Z54ud6es5CW9Xq5TCLGkDdgPYysZtgY0BERERFRsGwGbu/7yPW48YFGDP5wt6eAw7xWbWYqCRFgeGSsos0rnNa91Yggo1Ro5+ZljVw511qaX6t/QyNabIK6QTULzQ0pnH/6bGx56Hmsvedp+/EIQH6Xy9MuNH6+dw0en9GIr49+Li/gMtPKQtqs18tlEntH2/WPFyEM6IiIiIgoeKZZZlMNKIwbarcGFNaGFcPpscnH7J5brm6FTmMNnEolg1LO+Xi6dtRdhfVjd+SVXY6oOuyou6rgetl+7uaZd5Ys2hy8gW9Ysmi5xijNup+zw3q9psRRCMAul0RERERETnTb6rutnTI/t5zdCt1KG8Nqq2/t8AhEJ5t09so12HDfOG5UP0aTHMWgmoXbcAXaV67RH6dgk0VLySi+WvcvuP94u79rOrPFGItgkZAEXp7xBeCEFqBmA4D4zcBjQEdEREREodJtq+9l7VRun3LOYAOcSxuDDiytx1PIz07ddsYLWPrYXwO7KjuQ23hv1+Hyh5YXBLJr73na9jm6XS/nYAgvd6/0d6J26/UAQGW/Oy4z8KKMAR0RERERhUq3ZNBpf7vnlnMGWzFBB5Z2x8sFc3s/PQTcf2vRgdzlHJrtFORql4o6ZNFK7o56qCd/fd5ZVwIvPGz8LImpYC7HMgMvLjyNLRCRT4nI8yLyGxHptHl8q4g8nf3znyIybHpswvRYb5AnT0RERETRp9tW325/p+eWNIPN1L4eWxcZP/sUdGBZ9HjFBnLDfcxBuWiPU1i+wehyaWbujqrzuR3qwfiu67MBogKOHcH4wR8Yx+oaBlTG/nkxnJXoGtCJSA2A/wPgIgBnAPi8iJxh3kcptVYpdbZS6mwAtwO41/RwOveYUmpVgOdORERERDGgM3PNbv+GVBIn1ydtn6sdNOQab5hu9HHvGqBrpq/gLujh3kWP5zKQOypDs3U/dyzuAC7ZBsycC0CMvy/ZZmy3+9zuv8Hx8xp5cANqJ47nbaudOI6RB7PBYRXNSvRScvkxAL9RSr0EACLyYwCfAfCsw/6fB3BrMKdHRERERNVAt62+1/21Z7DZZbdy7UZ8rKNy6oBZauOSosd7rHhpYlTKUAH3z7GwNLQNq9ceLtyxWFbS5rOakX7N9vUmt1fRrEQvAV0zAPM3ph/Ax+12FJEPAVgAYI9p8wwR2Q9gHEC3Umqnw3PXAFgDAPPmzfNwWkREREREmsGiW0ldieuogh7uXfR4NcWDEb9jDsq1/k6rkYxLVtJqMDMLLQmb+XiZWWgB7GfgVaixjF9eAjqx2aZstgHAFQB+olTeCsN5SqlBEfkwgD0i8oxS6sWCAyq1HcB2AGhtbXU6PhERERFR6Zwab5iVuI4q6OHejsdzCUb8ZAvLOQZCq5GMZsOUYvPxunIbzDPwYsxLU5R+AHNNP7cAGHTY9woAPzJvUEoNZv9+CcBjAJZonyURERERURDsGm9YxWEd1eIOYO1ho8HH2sN5gYn22jUTpyDrKz2/woLO3Wjr3hNYcxWt0lC3hikWZ69cgw1qDfozjcgoQX+mERvUGpy9co3f044cLxm6fQBOE5EFAAZgBG1XWncSkYUATgbwuGnbyQBGlFLvi0gjgDYAm4M4cSIiIiIibXnZrSOAdWR3TNdRWZWaLXQKsiaUcY2CzNhplYZqlkgWm49XbVwDOqXUuIh8CcBDAGoAfE8p9R8ishHAfqVUbhTB5wH8WCllLpf8AwDfEZEMjGxgt1LKqZkKEREREVH4zKV21lllMV1HFRQvMwCDGtyuXRqqWSIZdAlsVEl+/BUNra2tav/+/ZU+DSIiIiKiacW6hs6JAHi5e2Ugr1euAehxIyIHlFKtbvt5KbkkIiIiIqJpwNpdMyEyWW5pVup8PbvXYwDnDwM6IiIiIiKaZA6y7DJ2fubrUfAY0BERERERka2g5+tR8BjQERERERGRI5ZFRpuXOXREREREREQUQczQERERERFRJLDrpT4GdEREREREVHHWBixBDjGvZgzoiIhiZmxsDP39/Th+/HilT4WoJDNmzEBLSwuSyWSlT4WIImTLQ88XzL8Laoh5NWNAR0QUM/39/fjgBz+I+fPnQ0QqfTpEWpRSOHr0KPr7+7FgwYJKnw4RRcjgcFprOxnYFIWIKGaOHz+OWbNmMZijWBIRzJo1ixlmIirgNKw8qCHm1YoBHRFRDDGYozjj95eI7KxbsRCpZE3etiCHmO88OIC27j1Y0Lkbbd17sPPgQCDHrTSWXBIRERERUcWFOcS8mhuuMKAjIiKKuVdeeQUXX3wxDh8+HPixH3vsMfz93/89fvazn6G3txfPPvssOjs7A38dItJTre39wxpiXs0NV1hySURU5cpdYvLpT38aw8PDGB4exh133DG5/bHHHsPFF18c6mvHwqEeYOsioKvB+PtQT6XPyLNVq1YxmCOKgFy2aWA4DYWpbFO1lBCGoZobrjCgIyKqYpX4P/0HHngADQ0NBQFdOY2Pj1fkdV0d6gHuvwE4dgSAMv6+/4ZAgrrx8XFcffXVWLx4MS677DKMjIxg48aNWLp0KRYtWoQ1a9ZAKQUA2LZtG8444wwsXrwYV1xxBQDgvffew5//+Z9j6dKlWLJkCXbt2lXwGnfddRe+9KUvAQD+7M/+DDfccAM+8YlP4MMf/jB+8pOfTO63ZcsWLF26FIsXL8att97q+70RUb5i2SayV80NVxjQERFVsTD+T3/z5s3Ytm0bAGDt2rVYtmwZAODRRx/FVVddhfnz52NoaAidnZ148cUXcfbZZ2PdunUAgHfffReXXXYZTj/9dHzhC1+YDDDszJ8/H7feeivOOeccnHnmmXjuuecAAG+++SZWr16NxYsX47zzzsOhQ4cAAF1dXVizZg0uvPBC/Omf/inuuusurF69GpdccgkWLFiAb3/72/jmN7+JJUuW4LzzzsObb75Z8jUo2aMbgbH/n707j6+6vvI//jrZ9wSysCRAWMImIJtYRFRwQazWdaxaW7XtaDvjdB07dTq1jm0t1s502pn2N7UWtYu2VtSi7aitYC24AAFkk31NgCQkJGRf7v38/vjeJDchCYEsN8v7+XjkkXu/93PvPffr9eYePudzPq3+Nbi+2jveRbt27eLee+9ly5YtJCUl8dOf/pT777+f9evXs23bNqqrq3n11VcBWLZsGZs2bWLLli387//+LwDf/e53Wbx4MevXr2f16tU88MADVFZWdvicx44dY82aNbz66qtNM3dvvPEGe/bsYd26dWzevJnc3FzefvvtLr8+EWk2kGebekpPN1wJJSV0IiIDWE/80b/kkkv429/+BsCGDRuoqKigvr6eNWvWsHDhwqZxy5YtY/z48WzevJnHH38cgE2bNvFf//Vf7Nixg/3797N27doOnystLY2NGzfy+c9/nh/84AcAfOtb32LWrFls2bKFRx99lE996lNN43Nzc/nDH/7As88+C8C2bdt49tlnWbduHd/4xjeIi4tj06ZNzJ8/n1/+8pfnfA7OWVne2R0/C6NGjWLBggUA3HnnnaxZs4bVq1dz4YUXMn36dFatWsX27dsBmDFjBp/4xCf49a9/TUSEt5z+jTfeYNmyZcycOZPLLruMmpoaDh8+3OFz3nDDDYSFhTF16lQKCgqaHueNN95g1qxZzJ49m507d7Jnz54uvz4RaTaQZ5t6yg2zMvneTdPJTInFgMyUWL530/R+v34O1BRFRGRAG5kSS34byVtX/ujPmTOH3NxcysvLiY6OZvbs2WzYsIG//e1v/PjHP+Z73/teu/edN28eWVlZAMycOZODBw9y8cUXtzv+pptuanrOF198EYA1a9awYsUKABYvXkxxcTFlZWWAt8YrNrb5tS1atIjExEQSExNJTk7muuuuA2D69OlNM3u9KjkrUG7ZxvEuar0VgJnxD//wD2zYsIFRo0bx8MMPN+399sc//pG3336blStX8u1vf5vt27fjnGPFihVMmtTyX6sbE7W2REdHN11unG11zvHggw9y3333dfk1iUjbHlgyqUXHRhg4s01n42wbw/RUw5VQ0wydiMgA1hMlJpGRkWRnZ/PUU09x0UUXsXDhQlavXs2+ffuYMmVKh/cNTgDCw8PPuNatcXzw2LbKNBuTmfj4+HafLywsrOl6WFhYaNbZXf4QRLZKpiNjveNddPjwYd59910AnnvuuaZEOS0tjYqKiqY1bn6/nyNHjrBo0SK+//3vU1paSkVFBUuWLOG///u/m87vpk2bzimOJUuWsHz5cioqKgDIz8+nsLCwqy9PRIIM5NmmzlJjmGaaoRMRGcB6ak+fSy65hB/84AcsX76c6dOn85WvfIU5c+a0mCVKTEykvLy8S8/T3nP/5je/4Zvf/CZvvfUWaWlpJCUldfvz9IgZt3q/33zEK7NMzvKSucbjXTBlyhSeeeYZ7rvvPnJycvj85z/PyZMnmT59OtnZ2VxwwQUA+Hw+7rzzTsrKynDO8eUvf5mUlBS++c1v8qUvfYkZM2bgnCM7O7tpzd3ZuOqqq/jwww+ZP38+AAkJCfz6178mIyOjy69RRJoN1NmmzhrI2xCcLSV0IiIDXE/80V+4cCHf/e53mT9/PvHx8cTExLRYPweQmprKggULmDZtGkuXLuWjH/1otzz3ww8/zD333MOMGTOIi4vjmWee6ZbH7TUzbu2WBC5YdnY2O3bsOO34d77zHb7zne+cdnzNmjWnHYuNjeVnP/vZaccvu+wyLrvsMsDrbHn33XcDXsfLYI0zcgBf/OIX+eIXv3gWr0BE5OyoMUwz66jDWNMgs6uBHwHhwJPOuWWtbr8beBxonOP8H+fck4Hb7gL+LXD8O865M/7lnTt3rtuwYUNnX4OIyKDy4YcfnrG0UaSv0/tYRLpiwbJVba4Rz0yJZe3XF4cgou5nZrnOublnGnfGNXRmFg78BFgKTAVuN7OpbQz9nXNuZuCnMZkbCnwLuBCYB3zLzIacxesQERERERFpYSBvQ3C2OlNyOQ/Y65zbD2BmvwWuB06v7TjdEuDPzrmSwH3/DFwNPHdu4YqIyEBz4403cuDAgRbHHnvsMZYsWRKiiEREpK/rqTXi/VFnErpMILjHch7ejFtrN5vZJcBu4MvOuSPt3LfNs2xm9wL3AowePboTYYmIDF7OudPa1PdXL730UqhDkF7WmeUeIiJnMtgbwzTqzLYFbX1jaP1J/AqQ7ZybAfwFaFwn15n7egede8I5N9c5Nzc9Pb0TYYmIDE4xMTEUFxfrS7H0S845iouLiYmJCXUoIiIDQmdm6PKAUUHXs4CjwQOcc8VBV38OPBZ038ta3fetsw1SRESaZWVlkZeXR1FRUahDETknMTExTRvMi4hI13QmoVsP5JjZWLwulrcBdwQPMLMRzrljgasfAz4MXH4deDSoEcpVwINdjlpEZBCLjIxk7NixoQ5DRERE+oAzJnTOuQYzux8vOQsHljvntpvZI8AG59xK4Atm9jGgASgB7g7ct8TMvo2XFAI80tggRURERERERLqmU/vQ9TbtQyciIiIiIoNZt+1DJyIiIiIiIn1Tn5yhM7Mi4FCo42hDGnAi1EEMUjr3oaXzHzo696Gl8x9aOv+ho3MfWjr/odOXzv0Y59wZ2//3yYSurzKzDZ2Z9pTup3MfWjr/oaNzH1o6/6Gl8x86OvehpfMfOv3x3KvkUkREREREpJ9SQiciIiIiItJPKaE7O0+EOoBBTOc+tHT+Q0fnPrR0/kNL5z90dO5DS+c/dPrdudcaOhERERERkX5KM3QiIiIiIiL9lBI6ERERERGRfkoJXSeY2dVmtsvM9prZ10Mdz0BnZqPMbLWZfWhm283si4HjD5tZvpltDvxcE+pYByIzO2hmWwPneEPg2FAz+7OZ7Qn8HhLqOAciM5sU9P7ebGanzOxLeu/3HDNbbmaFZrYt6Fib73fz/Djwt2CLmc0OXeT9Xzvn/nEz2xk4vy+ZWUrgeLaZVQf9P/C/oYt8YGjn/Lf7WWNmDwbe+7vMbElooh4Y2jn3vws67wfNbHPguN773ayD75n99rNfa+jOwMzCgd3AlUAesB643Tm3I6SBDWBmNgIY4ZzbaGaJQC5wA3ArUOGc+0FIAxzgzOwgMNc5dyLo2PeBEufcssA/agxxzv1LqGIcDAKfPfnAhcA96L3fI8zsEqAC+KVzblrgWJvv98CX238CrsH77/Ij59yFoYq9v2vn3F8FrHLONZjZYwCBc58NvNo4TrqunfP/MG181pjZVOA5YB4wEvgLMNE55+vVoAeIts59q9v/Ayhzzj2i93736+B75t30089+zdCd2Txgr3Nuv3OuDvgtcH2IYxrQnHPHnHMbA5fLgQ+BzNBGNehdDzwTuPwM3gef9KzLgX3OuUOhDmQgc869DZS0Otze+/16vC9gzjn3HpAS+GIg56Ctc++ce8M51xC4+h6Q1euBDRLtvPfbcz3wW+dcrXPuALAX7/uRnIOOzr2ZGd4/YD/Xq0ENIh18z+y3n/1K6M4sEzgSdD0PJRe9JvAvU7OA9wOH7g9Mdy9X2V+PccAbZpZrZvcGjg1zzh0D74MQyAhZdIPHbbT8g673fu9p7/2uvwe969PA/wVdH2tmm8zsr2a2MFRBDQJtfdbovd97FgIFzrk9Qcf03u8hrb5n9tvPfiV0Z2ZtHFOdai8wswRgBfAl59wp4P8B44GZwDHgP0IY3kC2wDk3G1gK/GOgNER6kZlFAR8Dfh84pPd+36C/B73EzL4BNAC/CRw6Box2zs0CvgI8a2ZJoYpvAGvvs0bv/d5zOy3/MU/v/R7SxvfMdoe2caxPvf+V0J1ZHjAq6HoWcDREsQwaZhaJ9z/Zb5xzLwI45wqccz7nnB/4OSr36BHOuaOB34XAS3jnuaCxvCDwuzB0EQ4KS4GNzrkC0Hs/BNp7v+vvQS8ws7uAa4FPuMBC/0CpX3Hgci6wD5gYuigHpg4+a/Te7wVmFgHcBPyu8Zje+z2jre+Z9OPPfiV0Z7YeyDGzsYF/Nb8NWBnimAa0QP34L4APnXP/GXQ8uF75RmBb6/tK15hZfGCBMGYWD1yFd55XAncFht0F/CE0EQ4aLf6FVu/9Xtfe+30l8KlAx7OP4DUtOBaKAAcqM7sa+BfgY865qqDj6YFGQZjZOCAH2B+aKAeuDj5rVgK3mVm0mY3FO//reju+QeAKYKdzLq/xgN773a+975n048/+iFAH0NcFOm3dD7wOhAPLnXPbQxzWQLcA+CSwtbFtL/CvwO1mNhNvmvsgcF9owhvQhgEveZ91RADPOudeM7P1wPNm9hngMPB3IYxxQDOzOLyuusHv7+/rvd8zzOw54DIgzczygG8By2j7/f4nvC5ne4EqvO6jco7aOfcPAtHAnwOfQ+855z4HXAI8YmYNgA/4nHOusw09pA3tnP/L2vqscc5tN7PngR14pbD/qA6X566tc++c+wWnr50Gvfd7QnvfM/vt0mVlJgAAIABJREFUZ7+2LRAREREREemnVHIpIiIiIiLSTymhExERERER6aeU0ImIiIiIiPRTSuhERERERET6KSV0IiIiIiIi/ZQSOhER6ffMrCLwO9vM7ujmx/7XVtff6c7HFxER6QoldCIiMpBkA2eV0DVu2tuBFgmdc+6is4xJRESkxyihExGRgWQZsNDMNpvZl80s3MweN7P1ZrbFzO4DMLPLzGy1mT0LbA0ce9nMcs1su5ndGzi2DIgNPN5vAscaZwMt8NjbzGyrmX086LHfMrMXzGynmf3GArtki4iIdLeIUAcgIiLSjb4O/LNz7lqAQGJW5py7wMyigbVm9kZg7DxgmnPuQOD6p51zJWYWC6w3sxXOua+b2f3OuZltPNdNwEzgfCAtcJ+3A7fNAs4DjgJrgQXAmu5/uSIiMthphk5ERAayq4BPmdlm4H0gFcgJ3LYuKJkD+IKZfQC8B4wKGteei4HnnHM+51wB8FfggqDHznPO+YHNeKWgIiIi3U4zdCIiMpAZ8E/OuddbHDS7DKhsdf0KYL5zrsrM3gJiOvHY7akNuuxDf29FRKSHaIZOREQGknIgMej668DnzSwSwMwmmll8G/dLBk4GkrnJwEeCbqtvvH8rbwMfD6zTSwcuAdZ1y6sQERHpJP2LoYiIDCRbgIZA6eTTwI/wyh03BhqTFAE3tHG/14DPmdkWYBde2WWjJ4AtZrbROfeJoOMvAfOBDwAHfM05dzyQEIqIiPQKc86FOgYRERERERE5Byq5FBERERER6aeU0ImIiIiIiPRTSuhERKTPCDQYqTCz0d05VkREZKDSGjoRETlnZlYRdDUOr12/L3D9Pufcb3o/KhERkcFDCZ2IiHQLMzsIfNY595cOxkQ45xp6L6r+SedJREQ6SyWXIiLSY8zsO2b2OzN7zszKgTvNbL6ZvWdmpWZ2zMx+HLRPXISZOTPLDlz/deD2/zOzcjN718zGnu3YwO1LzWy3mZWZ2X+b2Vozu7uduNuNMXD7dDP7i5mVmNlxM/taUEzfNLN9ZnbKzDaY2Ugzm2BmrtVzrGl8fjP7rJm9HXieEuDfzCzHzFabWbGZnTCzX5lZctD9x5jZy2ZWFLj9R2YWE4h5StC4EWZWZWap5/5fUkRE+ioldCIi0tNuBJ7F27z7d0AD8EUgDVgAXA3c18H97wC+CQwFDgPfPtuxZpYBPA88EHjeA8C8Dh6n3RgDSdVfgFeAEcBE4K3A/R4AbgmMTwE+C9R08DzBLgI+BNKBxwADvhN4jqnAuMBrw8wigD8Ce/H22RsFPO+cqwm8zjtbnZPXnXPFnYxDRET6ESV0IiLS09Y4515xzvmdc9XOufXOufedcw3Ouf14G3df2sH9X3DObXDO1QO/AWaew9hrgc3OuT8EbvshcKK9BzlDjB8DjjjnfuScq3XOnXLOrQvc9lngX51zewKvd7NzrqTj09PksHPu/znnfIHztNs596Zzrs45VxiIuTGG+XjJ5r845yoD49cGbnsGuCOwkTrAJ4FfdTIGERHpZyJCHYCIiAx4R4KvmNlk4D+AOXiNVCKA9zu4//Ggy1VAwjmMHRkch3POmVleew9yhhhH4c2MtWUUsK+D+DrS+jwNB36MN0OYiPePsEVBz3PQOeejFefcWjNrAC42s5PAaLzZPBERGYA0QyciIj2tdfetnwHbgAnOuSTgIbzywp50DMhqvBKYvcrsYHxHMR4Bxrdzv/Zuqww8b1zQseGtxrQ+T4/hdQ2dHojh7lYxjDGz8Hbi+CVe2eUn8Uoxa9sZJyIi/ZwSOhER6W2JQBlQGWje0dH6ue7yKjDbzK4LrD/7It5atXOJcSUw2szuN7MoM0sys8b1eE8C3zGz8eaZaWZD8WYOj+M1hQk3s3uBMWeIOREvESwzs1HAPwfd9i5QDDxqZnFmFmtmC4Ju/xXeWr478JI7EREZoJTQiYhIb/sqcBdQjjcT9ruefkLnXAHwceA/8RKh8cAmvBmws4rROVcGXAncDBQCu2le2/Y48DLwJnAKb+1djPP2CPp74F/x1u5NoOMyU4Bv4TVuKcNLIlcExdCAty5wCt5s3WG8BK7x9oPAVqDOOffOGZ5HRET6Me1DJyIig06gVPEocItz7m+hjqcnmNkvgf3OuYdDHYuIiPQcNUUREZFBwcyuxitVrAEexNuaYF2Hd+qnzGwccD0wPdSxiIhIz1LJpYiIDBYXA/vxSh6vBm4YiM1CzOx7wAfAo865w6GOR0REepZKLkVERERERPopzdCJiIiIiIj0U31yDV1aWprLzs4OdRgiIiIiIiIhkZube8I519EWO0AfTeiys7PZsGFDqMMQEREREREJCTM71JlxXSq5NLOrzWyXme01s6+3cftoM1ttZpvMbIuZXdOV5xMREREREZFm55zQBfbw+QmwFJgK3G5mU1sN+zfgeefcLOA24Kfn+nwiIiIiIiLSUldm6OYBe51z+51zdcBv8fa8CeaApMDlZLxNXEVERERERKQbdGUNXSZwJOh6HnBhqzEPA2+Y2T8B8cAVXXg+ERERERERCdKVGTpr41jrTe1uB552zmUB1wC/MrM2n9PM7jWzDWa2oaioqAthiYiIiIiIDA5dSejygFFB17M4vaTyM8DzAM65d4EYIK2tB3POPeGcm+ucm5uefsbunCIiIiIiIoNeV0ou1wM5ZjYWyMdrenJHqzGHgcuBp81sCl5Cp+k3EREREZFu9PKmfB5/fRdHS6sZmRLLA0smccOszFCHJb3gnBM651yDmd0PvA6EA8udc9vN7BFgg3NuJfBV4Odm9mW8csy7nXOtyzJFREREROQcvbwpnwdf3Ep1vQ+A/NJqHnxxK4CSukHA+mJ+NXfuXKeNxUVEREREzmzBslXkl1afdjwjMZp3vr6YiPAubT0tIWJmuc65uWca15WSSxERERERCaGy6vo2kzmAwvJapj70OuMzEpg4LIGJwxIDPwmMGhJHWFhbPQ6lv1FCJyIiIiLSz+wvquDpdw7yQm5eu2NS4iL5+NxR7C4oZ8PBk/xhc3P/wtjIcCZkJJAzLIFJjYne8ERGJsdgpkSvP1FCJyIiIiLSDzjnWLu3mOVrD7BqZyFR4WFcd/5IstPi+OnqfU1r6MBL2B6+7rwWa+jKa+rZU1jBnoJydhdUsLugnLV7T/DixvymMQnREUzI8JK8nMCs3qThiWQkRivR66OU0ImIiIiI9GE19T5e2pTPU2sPsLuggrSEKL54eQ6f+MhoMhJjABg1JO6MXS4TYyKZPXoIs0cPaXG8rKqe3YXl7C4oZ/dxL9n7y4cF/G7DkaYxSTERTBqeSM6wRCZmJDBxuDerl5YQ3fMnQDqkpigiIiIiIn3Q8bIafvXeQZ59/zAnq+qZOiKJT188luvOH0F0RHiPP39xRW3TTF7zTwVl1fVNY1Ljo5pm8oLX6KXERfV4fAOdmqKIiIiIiPRDm4+UsnzNAf609Rg+57hyyjA+ffFYLhw7tFfLHlMTopmfEM388alNx5xzFJXXsquxbPN4ObsLy3lxYz4VtQ1N4zISo1skeBOHJ5KTkUBiTGSvxT9YKKETEREREQmxep+f17Yd56m1B9h4uJSE6Ajuuiibu+ZnMzo1LtThNTEzMpJiyEiKYWFOetNx5xxHy2palG3uKSzn2XWHqKn3N40bmRzTVK6Zk5HApOGJTMhIIC5Kacm50pkTEREREQmR0qo6nlt3hF++e5BjZTWMSY3jW9dN5ZY5Wf1qNsvMyEyJJTMllkWTMpqO+/2OvJPVgRm9cvYUlLOroIJ39hVT1+AP3NdbAzhxWAI5wxKbGrKMT08gJrLnS0v7OyV0IiIiIiK9bG9hOcvXHuTFjXnU1Pu5aHwq375+GosmZxA+gPaHCwszRqfGMTo1jiunDms63uDzc6ikqqnj5q5AsvfWriIa/F6PjzCD7NT4pq0VcgIdN7NT44mK0GbpjZTQiYiIiIj0Ar/f8faeIpavPcjbu4uIigjjxpmZ3L0gmykjkkIdXq+KCA9jfLo3C3f1tObjdQ1+DhZXtijd3F1Qzp93FBDI84gIM8amxXulmxmJTBruzeyNGRpHRPjgS/SU0ImIiIiI9KCqugZWbMzn6bUH2FdUSXpiNF+9ciJ3XDiaVLX9byEqIqypmQozmo/X1PvYX1TZouPm1rwy/rT1GI1N+6MivCRxYouumwmMGhJHWBuzni9vyj/jVg/9gRI6EREREZEekF9azS/fPchz7x/mVE0D0zOT+eHHz+ej00eqZPAsxUSGM3VkElNHtpzJrKprYG9hRYvtFTYcPMkfNh9tGhMbGc6EjISm0s2JwxI5WFzJ91/bSXWgYUt+aTUPvrgVoN8lddqHTkRERESkmzjn2Hj4JMvXHOS17cdxznH1tOF8esFY5owZ0qvbDgxm5TX17CmsaNFxc9fxcgrLazu8X2ZKLGu/vriXouyY9qETEREREekldQ1+/rT1GE+tPcAHeWUkxUTw2YvH8sn5Y8ga0ne2HRgsEmMimT16CLNHD2lxvLSqjt0FFdz6s3fbvN/R0ureCK9bKaETERERETlHJZV1PPv+IX757iEKy2sZlxbPt68/j5tmZxEfra/afU1KXBTzxg4lMyWW/DaSt5EpsSGIqmv0LhMREREROUu7jpfz1NoDvLQpn9oGPwtz0njslhlcmpPeZgMO6VseWDKJNS/9lC/xW0baCY66NP6L27h4yT+EOrSzpoRORERERKQT/H7H6l2FLF97gLV7i4mJDOOm2VncsyDb68oo/cYN4Wu5NvJJInw1AGTZCZaFP0lE+PnAraEN7iwpoRMRERER6UBFbQMrcvN4au0BDhZXMTwphq9dPYnbLxjNkPioUIcn5+LNR5qSuUYRvhp48xGYoYRORERERKTfO1JSxTPvHOR3649QXtvArNEpfOWqSSydNpzIQbiBdb/n98PxD2DfKig70vaYsrzejakbKKETEREREQlwzrHuQAnL1x7gzzsKMDOumT6CexZkn9YxUfqBU8dg/2rY+6b3u6rYOx4WCf7608cnZ/VufN1ACZ2IiIiIDHq1DT5e/eAYy9ceYPvRU6TERfK5S8fzyfljGJHc/zofDlr1NXD4HS+B27caCrd7x+PTYcIVMP5yGHcZHPgrvPIFqA/qdBkZC5c/FIqou0QJnYiIiIgMWkXltfzm/UP8+r3DnKioZUJGAo/eOJ0bZ2USGxUe6vDkTJyDop1eGeXeN+HQWmiogfAoGP0RuOLfYfxiGDYNwoLKZBvXyb35iFdmmZzlJXP9bP0cKKETERERkUFo+9Eynlp7kJWbj1Ln87NoUjqfvngsF09Iw0zbDvRpVSWBMspVXiJXftQ7njYR5tzjJXDZCyAqvuPHmXFrv0zgWlNCJyIiIiKDgs/v+MuHBSxfc4D3D5QQGxnOxy8Yxd0LshmfnhDq8KQ9vnrIWx8oo1wFRzcBDmJSvPLJ8Yu9n5RRIQ40NLqU0JnZ1cCPgHDgSefcsla3/xBYFLgaB2Q451K68pwiIiIiImejvKae5zfk8fQ7BzhSUk1mSiz/es1kPj53NMlxkaEOT9pSsr95HdyBt6GuHCwcsubCZQ/ChMth5CwIU1nsOSd0ZhYO/AS4EsgD1pvZSufcjsYxzrkvB43/J2BWF2IVEREREem0gycqefqdg/x+wxEq63xckD2EB5dO4aqpw4jQtgN9S80pL3Hbtwr2vQknD3rHU0bD9Fu8Gbixl0Cs5oZa68oM3Txgr3NuP4CZ/Ra4HtjRzvjbgW914flERERERDrknOPdfcUsX3uAN3cWEhFmXDtjJPcsyGZGlpKBPsPvg6ObmxO4I+vA+SAy3kvcPvKP3izc0HGgNY0d6kpClwkE78iXB1zY1kAzGwOMBVa192Bmdi9wL8Do0aO7EJaIiIiIDDY19T5Wbj7K8rUH2Hm8nKHxUdy/aAJ3fmQMw5JiQh2eAJTlNydw+9+C6pPe8REzYcEXvQQuax5ERIU0zP6mKwldW6mya2fsbcALzjlfew/mnHsCeAJg7ty57T2OiIiIiEiTwlM1/Oq9Qzz7/mGKK+uYPDyR7988g4/NHElMpNZXhVRdFRx6pzmJK9rpHU8YDhOXegncuMsgPi2UUfZ7XUno8oDgVjJZwNF2xt4G/GMXnktEREREpMnWvDKWrz3Aq1uO0uB3XD55GJ9ekM388anadiBUnIOC7c0J3KF3wVcL4dEw5iKY+QkvicuYqjLKbtSVhG49kGNmY4F8vKTtjtaDzGwSMAR4twvPJSIiIiKDyMub8nn89V0cLa1mZEosDyyZxLUzRvDGDm/bgQ2HThIfFc4nLhzD3Rdlk512hj3HpGdUFHnlk/sCWwpUFHjH06fABZ+FCYth9EUQFRfSMAeyc07onHMNZnY/8DretgXLnXPbzewRYINzbmVg6O3Ab51zKqMUERERkTN6eVM+D764lep6b7VOfmk1//z7D3h45XZKq+sZNTSWb147lb+bm0VSjLYd6FUNdXDk/eYE7tgH3vHYITBuUaCMchEkZ4Y2zkHE+mKeNXfuXLdhw4ZQhyEiIiIivai6zkdxZS03/uQdiipqT7s9KjyM/75jFldMGUZ4mEr2eoVzULyvOYE78Deor4SwCK+ByYTApt4jZmpPuG5mZrnOublnGteljcVFRERERNpT1+CnpLKO4spaiiuCf9dRXBF0OXC8qq7d/nkA1Pv8LDlveC9FP4hVlwb2hAskcaWHveNDxsLM270ELnshxCSFNk4BlNCJiIiISCf5/I6TVXVeIlZR25yYVdZxoqKOklYJ26mahjYfJzLcGBofRWp8NKkJUWSnxpGa4F1OjY/isdd2UVJZd9r9RqbE9vRLHJx8DXB0k5fA7X0T8jeA80NUorcn3IIveknc0HGhjlTaoIROREREZJDy+x2nauoDCZiXhJ2orKOkou1ZtZNVdbS1WifMYGh8VFOSdt7IJNISor3rCc2JW2p8FKkJ0STFRHTYiTI6IrzFGjqA2MhwHlgyqSdOw+BUeqR5Bm7/W1BTBhiMnAULv+olcFkXQLjWKPZ1SuhEREREBgjnHJV1Pi8xq6jzyh2bZtBqA9ebL5dU1tHgb7ufQnJsJKkJUaTFRzM+PYF5Y71kLDUoSUtL8JK4lLiobl3TdsMsr6FG6y6XjcelDVuehzcfgbI8SM6Cyx+CGbc2315XCQfXeAnc3jeheI93PHEkTLnOS+DGLYK4oaGJX86ZmqKIiIiI9IK22vB3JkGpqfe1mYw1JmnFQYnbico66hr8bT5OQnREyxmzxssJzYlZY5I2JD6KyPCw7j4F0lO2PA+vfAHqq5uPRcbCwn/2GpXsfdPrTOmrg4gYGLPA60Y5/nJIn6Q94fqozjZFUUInIiIi0sNat+EHiI4I454F2UwenuQlZkGljsGza5XtNAqJjggjLbDuLDgZGxooa2ycXRsaKHWMiVQHwgHrh9Og7Ej7tw+bBuMXebNwoy+CyJjei03OmbpcioiIiPSS6jpvFq2oopYT5YESx/JaTgRKH/+8o4A6X8uZs9oGP//71/1N1yPCrCkZS0uIYkxqXNPaMy9Ra5mkxUeFd7gOTQYY56D6JJTsD/wcaL7cUTL31V2QqM6gA5kSOhEREZFWnHOcqmloWovmJWZesnaiVbJ2oqK23Xb7iTERpCdEn5bMNTLgL1+9lLT4aJJiO24UIoOAc1BRGJS0BX5OBpK3mrKW45OyYOhYiIz39oZrLXmUkrlBQAmdiIiIDAr+QMv9Fgla4+VAgtY0s9bOWjQzGBoX1VTqOHNUCmkJ0aQlejNnaYnebY23R0d4ZY4Llq0iv7T6tMcbmRLL+PSEHn/t0of4/XAqv2Wi1jTjdqBlYmbhkDLK2y5g+t95v4eMDfwe462Tg/bX0F3+UO++NgkJJXQiIiLSb9X7vI2ri4JmzIpbJWtFgRLIkso6fG10dIwIs0BZo5eI5WQkktZ4vVWCNjQuiohzaBbywJJJasM/mPgaoOxwq9LIwO+TB8FX2zw2PAqGZHuJWvZCL1kbOs6beUsZ3bltAxq7WXbU5VIGLCV0IiIi0qfU1PuakrDm0sbaNmfWSqvq23yMmMiwpkQsa0hs80xaU1fHaNIDyVpybGSPlzqqDf8A1FALJw+dXh7ZuKbNH7SpekSsl6Sl5cDEJV6y1pi4JWV6nSi7asatSuAGKXW5FBERkXPS2Tb8zjkqahtalje2StaKm5K1OipqG9p4Nm89WmNSFjxrlhaUoKXGR5OWGK2GIdI96iqDZtZalUeW5QFB36Ojk1omao0/Q8Z669j0fpSzpC6XIiIi0mNat+HPL63mgRc+4I9bjjI0Pvq0mbTadtajDYnzOjimxkczPSulKVlLD07WEqPVdl96TnVp22vZSvZDxfGWY+NSvSRtzEXNa9kaf+KGKmmTkFBCJyIiIp1yoqKWrfllbM0r46er91LTKkmr9zn+/GEhGYnRTYnY+IyElslZ04+3X9q5rEcTOSvOQVVxyzb/wd0jq4pbjk8Y7iVoE64ImnEb6yVwsSmheQ0iHVBCJyIiIqcprapja34ZW/K8BG5rfllTl0Yz7ztyWwxY940rei9QGbi2PN/5Jh/OQfnx09v8N8641Z4KGmxeO/+hY2HKda3KI7MhKr43Xp1It1FCJyIiMsidqqlnW2DmbUvg9+GSqqbbx6bFM2fMEO5ZkM30zGTOy0xmyQ/fbrcNv0iXtW7DX3bEu15VDBlTTi+PPHkA6pvfs1i419Z/6DgYdWHL8sghYyAiOjSvS6QHKKETEREZRKrqGth+9FRg5q2ULfll7C9q3vcqa0gsM7KSuX3eaM7P8pK35NjT26arDb/0qDcfabmnGnjXX/t68/XwaG9Gbeg4GHdZy/LI5FGda/cvMgAooRMRERmgaup97Dh2ypt5yytja34pewsraNyKbURyDNMzk7lpVibTs1KYnpnM0PioTj222vBLjyne583IteeuV7zELXEkhGkNpogSOhERkQGgrsHPruPlbMkvZWteGR/klbG7oLxpI+20hChmZKWwdNoIzh+VzLTMZDISY7r0nDfMylQCJ93D74Pdr8H6J2HfqvbHJY+CsZf0Xlwi/YASOhERkX6m3udnT0EFW/NLAzNvZew8Vk6dz+s6OSQukulZKVw+OYPpWcnMyEpmeFKM9mWTvqeiEDb+EnKf9mblEkfCom9A7BD48zdbll1GxnqNUUSkBSV0IiIifZjP79hfVNGUuH2QV8qOo6ea9nVLjIlgemYy91yczfmBssmsIbFK3qTvcg6OvO/Nxm1/Gfz1MPZSWPIoTLoGwgNfT2OSO9/lUmQQU0InIiLSR/j9joPFlS22C9h2tIyqOq/xSFxUONMyk/nkR8YEZt5SGDM0jrAwJW/SD9RWwNbnYf0voGAbRCfDBZ+FuZ+G9Imnj59xqxI4kU5QQiciIhICzjmOlFQ3rXnbklfGtvwyymsbAIiOCOO8kUncOncUMwJlk2PTEghX8ib9TdFubzbug+e8/eCGTYfrfgTT/057vol0gy4ldGZ2NfAjIBx40jm3rI0xtwIPAw74wDl3R1eeU0REpL9xznGsrKap02Rj+WRpVT0AUeFhTBmRyPWzRjIjM4XpWcnkZCQQEa4OftJP+Rpg1x+9RO7A2xAeBVNv8GbkRs3zdqcXkW5xzgmdmYUDPwGuBPKA9Wa20jm3I2hMDvAgsMA5d9LMMroasIiISF9XeMpL3rxNukvZml/GiYo6ACLCjInDElk6bTjTM1OYkZXMxGGJREUoeZMBoPw45D7jNTkpP+p1pbz8IZj1KUhID3V0IgNSV2bo5gF7nXP7Aczst8D1wI6gMX8P/MQ5dxLAOVfYhecTERHpc4oratma76132xL4ffxUDQBhBjkZiVw2KYMZWclMz0xmyogkYiLDQxy1SDdyDg6t9WbjPnwF/A0w/nK49j8h5yoI0/tdpCd1JaHLBIJ3fcwDLmw1ZiKAma3FK8t82Dn3WlsPZmb3AvcCjB49ugthiYiInJuXN+V3uFF2WVW917AkaN1bfqnXVt0MxqXFM398KtMzvTVvU0cmERel5eoyQNWcgi2/85qcFH0IMSlw4ee8Jiep40Mdncig0ZW/Mm0VP7s2Hj8HuAzIAv5mZtOcc6Wn3dG5J4AnAObOndv6cURERHrUy5vyefDFrVTXex0l80ur+dqKLazaWYDfwdb8Mg4VVzWNH5Max6zRKdx10RhmZKVw3sgkEmMiQxW+SO8p2OHNxm35HdRVwIiZcP1P4LybICou1NGJDDpdSejygFFB17OAo22Mec85Vw8cMLNdeAne+i48r4iISLd77LWdTclco7oGPys/OEZmSiwzspL5+AWjmJGZwrTMJFLiokIUqUgINNTBzle82bhDayE8Gqbd7DU5yZoT6uhEBrWuJHTrgRwzGwvkA7cBrTtYvgzcDjxtZml4JZj7u/CcIiIi3ebgiUpW7Sxk9a5CjpXVtDnGgLVfX9y7gYn0FWX5XoOTjc9ARQGkjIErH4GZd0J8aqijExG6kNA55xrM7H7gdbz1ccudc9vN7BFgg3NuZeC2q8xsB+ADHnDOFXdH4CIiImerrsHPugMlrNpZyFu7Ctl/ohKA8enxJESHU1HrO+0+I1NieztMkdByDg781Sur3PkncH6vuckFn4UJV0CYOrKK9CVdWqntnPsT8KdWxx4KuuyArwR+REREel3hqRpW7ypk1c5C1uw5QWWdj6iIMOaPS+Wui7JZNCmD0alxp62hA4iNDOeBJZNCGL1IL6ouhQ9+6yVyxXsgdihcdL/X5GRIdqijE5F2qPWWiIgMKD6/44O8UlYHSim35Z8CYERyDNfPymTxpAwumpB6WvfJxm6WHXW5FBmQjm+FdT+Hrb+H+irInAs3/szbCDwyJtTRicgZKKETEZF+r6y6nrd3F7F6ZyFv7S6ipLKOMIM5EG7sAAAgAElEQVQ5Y4bwwJJJLJ6cweThiZi11aC52Q2zMpXAyeDQUAs7VsL6n8OR9yEiFqbfAhd8BkbOCnV0InIWlNCJiEi/45xjd0FFUyll7qGT+PyOlLhILpuYzqLJGVw6MV2dKEVaKz0MG56Cjb+EqhMwdBwseRRm3gGxQ0IdnYicAyV0IiLSL1TX+Xh3/wmvK+XOoqYNvaeOSOJzl45j8eQMZo4aQnhYx7NwIoOO3w/7V3lbDux+zTs2cak3GzdukZqciPRzSuhERKTPOlJSxVuBWbh39hVT2+AnLiqcBRPSuH/xBBZNymB4stb4iLSpqgQ2PwsbfgEl+yEuDS7+Msy5B1JGnfn+ItIvKKETEZE+o97nJ/fQSVbv9JK4PYUVAIxJjeP2eaNZPDmDC8cNJToiPMSRivRhRzd5nSq3vgANNTB6Piz6Bky5DiKiQx2diHQzJXQiIhJSJypq+euuIlbtKuTt3UWU1zQQGW7MGzuUj18wisWTMxibFn/GhiYig1p9DWx/0Uvk8nMhMh7Ov90rqxw+PdTRiUgPUkInIiK9yu93bD96ilU7C1m1q5AteaU4B+mJ0SydNpzFkzNYMCGNxJjIUIcq0veVHIANy2HTr6G6BNImwtLvw/m3QUxyqKMTkV6ghE5ERHpceU09a/cGGprsKqKovBYzOD8rhS9fMZHFkzOYOiKJMDU0ETkzvw/2/sWbjdvzZ7AwmPxRuOCzMPYS0Gy2yKCihE5ERLqdc479Jyqb1sKtP1hCvc+RGBPBJRPTWTwpg0snpZOWoPU8Ip1WWQybfuXNyJUegoRhcOnXYM7dkDQy1NGJSIgooRMRkW5R2+Dj/f0lgVm4Qg4VVwEwcVgCn754LIsnZTB7zBAiw9UiXaTTnPPWxK37OWx/CXy1MOZiuPLfYfK1EK7SZJHBTgmdiIics2Nl1azeWRTYVuAEVXU+oiPCuGh8Kp+9eCyXTcpg1NC4UIcp0v/UVcG2FbD+53DsA4hKgNmf8pqcZEwJdXQi0ocooRMRkU7z+R2bj5z0GprsLOLDY6cAyEyJ5ebZWSyanM78cWnERmlbgUFhy/Pw5iNQlgfJWXD5QzDj1lBH1b8V7/M2AN/8a6gpg/Qp8NH/gBkfh+jEUEcnIn2QEjoREelQaVUdf93tzcL9dXcRpVX1hIcZc8YM4etLJ7N4cgY5GQnaVmCw2fI8vPIFqK/2rpcd8a6Dkrqz5ffB7te8Jif7VkFYBEz5mNfkZMxFanIiIh1SQiciIi0459h5vNxbC7ezkI2HT+J3kBofxeLJGSyalMElOekkx2ntzqD25iPNyVyj+mp45Utw+D1vbVdYBIRHeZfDIyEssvl6u7dFtLwcHhW43sa4xtvCwvtH0tN6RnPBl6CmFHKf9hLixJHeBuCz74LEYaGOVkT6CSV0IiJCVV0Da/cWs2pnIW/tKuRYWQ0A0zKTuH/RBBZNzmBGVgrh2lZAAI5v8xKQttRXwo6XwdcA/nrw1YG/oYcDsqBkr/EnqmXS2J0JZFvjmp4vsu3bdr8Ob/47NHj/b1F2BP70Ve/y2Evh6u/BxKXeY4uInAV9aoiIDGAvb8rn8dd3cbS0mpEpsTywZBI3zMoE4HBxFat2FrBqVxHv7S+mrsFPfFQ4C3PS+dIV6SyalEFGUkyIX4H0Gb4G2PUneP9ncGgNYIA7fVzyKPjytpbHnANffXOCF5zs+RoCSV99q8sd3db4E0gWW1yua77d33pc4LaGOvBXthrXwfP1pIThcNfKnn0OERnQlNCJiAxQL2/K58EXt1Jd7wMgv7Sar72whZc35XHkZDX7iioBGJcWzyc/MobFkzO4IHsoURHaVkCCVJXAxmdg3ZNwKs9L2K58xGvQ8fq/tiy7jIz1GqO0ZgYRUUAUEN9bkXcP59pIGs8ygfQ3wIt/3/bjVxT07usRkQFHCZ2IyADknGPZ/+1sSuYa1fn8vLX7BAtz0vjEhV4Sl53Wz75gS+84vtWbjdv6e69MMHshLF3WsiwwKmHgd7k0ay6dpAtbcLz5SNtlqslZ5/6YIiIooRMR6df8fkfeyWr2FpWzt7CCPQUV7C2qYG9hBeU1ba9bMuBXn7mwdwOV/sHXALv+CO8/4ZVVRsTC+bfBvHth2Hmnj59x68BL4HrK5Q+17AoK7c9oioicBSV0IiL9QF2Dn0PFlewp9JK1xp99RRXUNvibxqUlRDE+PYHrZ47klQ+OUlZ9elI3MiW2N0OX/qCy2CurXP+LQFnlaK+sctYnIW5oqKMbGBoT34E+oykivU4JnYhIH1JV18C+wsrTZtwOFVfh8zc3oMhMiWVCRgLzx6eSk5HAhMBPSlxU05i5Y4a2WEMHEBsZzgNLJvXqa5I+7NgWWPcz2PqCV1Y59hJY+hhMWuptBSDdSzOaItIDlNCJiIRAaVXdabNtewsryC9tLscKDzOyU+PIyUhg6bThXtKWnsj4jHjios788d3YzbK9LpcySPkaYOersO4JOLQ2UFZ5e6CscmqooxMRkbNkzrXRcrizdza7GvgREA486Zxb1ur2u4HHgfzAof9xzj15psedO3eu27BhwznHJSLSFzjnKDhVG0jWypsSuH1FFZyoqGsaFx0Rxvh0b4YteLZtTGq8Ok5K96ksho1Pw/rlXlllymgviZt1J8QOCXV0IiLSipnlOufmnmncOc/QmVk48BPgSiAPWG9mK51zO1oN/Z1z7v5zfR4Rkb7O53ccKanyEreioPVthRWU1zavYUuKiWBCRgKLJ2c0JW05GYlkpsQSpg27pac0llVu+T34ar1NrK95HCYuUVmliMgA0JWSy3nAXufcfgAz+y1wPdA6oRMRGRBqG3wcPOElbnsKy5sSt/0nKqkLakySnhjNhPQEbpydGSiT9JK39MRozJS4SS/wNcDOV7xulYffgcg4mPUJb0YuY0qooxMRkW7UlYQuEwjeUCUPaKsP9s1mdgmwG/iyc66NTVjAzO4F7gUYPXp0F8ISEemaitoG9jWuawuacTtc0tyYxAyyhsQyIT2BhTlp5GQkMj6QvCXHRYb4Fcig1VRW+Qs4lQ8pY+Cq73rJnMoqRUQGpK4kdG39M3PrBXmvAM8552rN7HPAM8Dith7MOfcE8AR4a+i6EJeISKeUVNY1JWuNM277Cis4WlbTNCYizMhOi2fy8ESunTGCCRkJjE/3fmKjVK4mfcSxD7zZuK2Bsspxl8E1P1BZpYjIINCVhC4PGBV0PQs4GjzAOVccdPXnwGNdeD4RkbPmnONYWU1zJ8mgGbeSyubGJLGR4YzPiGfe2KHkDEtsalIyJjWOyHA1JpE+yFfvdat8/2dw+N1AWeWdgbLKyaGOTkREeklXErr1QI6ZjcXrYnkbcEfwADMb4Zw7Frj6MeDDLjyfiAgvb8pvsw1/g8/PkZPVp8227SuqpCKoMUlybCQ5GQlcNXWYN9sW6Cw5MlmNSaSfqDwBuU97ZZXlR2FIdqCs8k6ITQl1dCIi0su6um3BNcB/4W1bsNw5910zewTY4JxbaWbfw0vkGoAS4PPOuZ1nelxtWyAibXl5U/5pG2WHm9eEpKSynjpfc2OSYUnRTV0kxwc1JklLiFJjEumfjm729o7b+kKgrHIRXHgf5FylskoRkQGos9sWdCmh6ylK6ESktfKaehY+tprS6vrTbouJCOOui7KbZtvGZySQFKPGJDIA+Orhw1e8ssoj70FkPJx/m8oqRUQGgR7fh05EpKf5/I539p1gRW4er20/Tk29v81xtQ1+HrxGrdhlAKk8AblPeZuAN5ZVLnkUZn5CZZUiItKCEjoR6XP2FVWwIjePlzblc6yshqSYCG6Zk8Xr2wooqqg9bfzIlNgQRCnSA45u8rpVbnsBfHUwfjFc+0PIuVJllSIi0iYldCLSJ5RV1/PqlqO8kJvHpsOlhIcZl05M598+OpXLp2QQExnO3DFDT1tDFxsZzgNLJoUwcpEu8tXDhysDZZXve2WVsz/llVWm670tIiIdU0InIiHT4PPzt71eSeUbOwqoa/AzaVgi37hmCtfPGklGYkyL8TfMygRos8ulSL9TUeR1q9zwCyg/BkPGwpLveZuAxySHOjoREeknlNCJSK/bXVDOitw8XtyUT1F5LUPiIrlj3mhumZPFeSOTOuxCecOsTCVw0r8d3eTNxm1b0VxWed2PYMKVEKY9D0VE5OwooRORXnGyso5XAiWVW/LKiAgzFk3O4ObZWSyenEFUhL7IygDmq4cdf/ASubx1EJUAs+8KlFVODHV0IiLSjymhE5EeU+/z89ddRbyQm8ebOwuo9zmmjkjioWun8rGZI0lLiA51iCI9q6IwUFa5vLms8uplMPMOlVWKiEi3UEInIt1ux9FTrNiYxx8253Oioo60hCg+NT+bm2dnMXVkUqjDE+l5+Ru92bjtLwbKKi+H634ME65QWaWIiHQrJXQi0i1OVNTyh81HWZGbx45jp4gMN66YMoybZ2dx6aR0IsP1JVYGuIa65m6VjWWVc+72yirTckIdnYiIDFBK6ETknNU1+Fm1s5AXcvN4a1chDX7HjKxkHrn+PK6bMZIh8VGhDlGk51UUwoanvLLKiuMwdBxc/VigrFIz0iIi0rOU0InIWXHOsS2/uaTyZFU9GYnRfObisdw8J4uJwxJDHaJI78jPDZRVvuSVVU64Ai78H6+8UmWVIiLSS5TQiUinFJbX8PKmfFbk5rOroJyoiDCumjqMm+dksXBCGhEqqZTBoKHO61a57meQtz5QVnkPzPt7lVWKiEhIKKETkXbV1Pt488NCXsg9wtt7TuDzO2aNTuG7N07j2ukjSY6LDHWIIr2jvAByG8sqC2DoeFj6fTj/dpVViohISCmhE5EWnHNsPlLKio15rNx8lFM1DYxIjuG+S8Zx85wsxqcnhDpEkZ6z5Xl48xEoy4PkLJj1SSjZB9teBH+9t/n3hZ/zNgNXWaWIiPQBSuhEBIDjZTW8uCmPFbl57CuqJCYyjKvPG84tc0Yxf3wq4WEW6hBFetaW5+GVL0B9tXe97Ai89SiER8MFn4EL/h7SJoQ2RhERkVaU0IkMYtV1Pt7YcZwXcvNYs/cEzsEF2UO495JxXDN9BIkxKqmUAa6yGI5vgYJtsPrR5mQuWHwaLH2s92MTERHpBCV0IoOMc47cQydZsTGPVz84RnltA5kpsfzT4hxunp3JmNT4UIco0v38fjh5wEvejm8N/GyD8qNnvu+pTowREREJESV0IoNE3skqXtqYz4qNeRwsriIuKpyl00Zwy5wsLhw7lDCVVMpAUVcFhTuCEretULAd6iu92y0c0ifB2IUwfLr3M2w6PHGpV2bZWnJW78YvIiJyFpTQiQxgVXUN/N/W46zYmMc7+4oBmD8ulfsX57B02nDio/URIP1ceUEgaQuUTR7fCsV7wfm926OTvIRt1p3NyVv6ZIiMOf2xLn+o5Ro6gMhY77iIiEgfpW9zIgOM3+9Yd7CEF3Lz+L+tx6is8zF6aBxfuXIiN87KZNTQuFCHKHL2fA1et8nG5K2xZLKysHlM8mgvYTvvJhg+zbucMgask7PPM271fgd3ubz8oebjIiIifZASOpEB4nBxFSs25rFiYx55J6tJiI7g2hkjuWVuFnPHDME6+6VWJNRqy70SyeCSycId0FDj3R4WCRlTIOfKoJLJ8yB2SNefe8atSuBERKRfUUIn0o9V1Dbwpy3HeGFjHusOlGAGF09I45+vmsSS84YTGxUe6hBF2uec13CkaZ1b4HfJ/uYxsUO8hO2Cz8KwwKxb2kSIiApd3CIiIn2IEjqRfsbvd7y7v5gXcvN4bdtxqut9jEuL54Elk7hxViYjU2JDHaLI6Xz1ULSreZ3b8S1eyWR1SfOYoeO8pO38OwIzb9MgKbPzJZMiIiKDUJcSOjO7GvgREA486Zxb1s64W4DfAxc45zZ05TlFBqsDJypZkZvHixvzOFpWQ2JMBDfOzuSWOVnMGpWikkrpO6pLgxK3bV7yVrQTfHXe7RExkDEVplzXsmQyOjG0cYuIiPRD55zQmVk48BPgSiAPWG9mK51zO1qNSwS+ALzflUBFBqOy6nr+uOUYKzbmkXvoJGEGl0xM58FrpnDl1GHERKqkUkLIOSg93Gp7gK3esUbx6V7CNv7zMHyGNwOXOgHCVSAiIiLSHbryF3UesNc5tx/4/+zdd3iV9f3/8ec7exASlkBImCJDCBsEBBFUXKC11r1nsXyx1tpqbdVarVb709ZW21oHWveqgqJi3agIQQgbkZ2EmZBAQnY+vz/uk+QkJCSQhJPxelxXrpzzue9z3+8TD5IXn4WZvQKcA6yuct4fgIeAX9bjXiIt1ttL03j4w3WkZ+URHxfJraceR4eYcN5Yksr8VTsoKC6l7zFtuOOM/pw7rBud21az3LpIYysugF1r/HrefL1vBdm+Eww69oWEUTDiai+8dRkMMZ0DWraIiEhLV59A1w3w34E1FRjjf4KZDQMSnXPvmpkCnUgVby9N4463VpBXVAJAWlYev3g9BYC4qFAuHJXI+SMSGNwtVkMq5ejJzahYoGSHL8DtWQelxd7x0GhviOTg8yuGTB4zAMKiA1u3iIhIK1SfQFfdb5eu/KBZEPAocFWdLmZ2A3ADQPfu3etRlkjz8eD7a8vDnL/2UaF885sphIdoSKXU0/LXat5XrbQU9m6qMmRyJexLq3h9TLwX2Pqd7gtvSdCuFwQFBeb9iIiISCX1CXSpQKLf8wQg3e95DDAI+MzXs9AFmGNm06tbGMU59yTwJMDIkSNd1eMiLcXe3ELeX7mDOSlp7NiXX/05B4oU5qT+lr8Gc2dBUZ73PHsbvHMTLH0RivO8vd4Kc7xjFgyd+kHPE32LlPi2CIjuGLj6RUREpFb1CXSLgb5m1gtIAy4CLik76JzLBsp/EzCzz4BfapVLaY1yC4r5aPVO5qSk88X3uykudfTuFE1MRAj784sPOl9bD8ghlRRB3l7v60BmxeO8zMpt696HkoKDX7vpc+g+FoZeWjFkslN/CNX8TBERkebmiAOdc67YzGYCH+JtW/CMc26Vmd0LJDvn5jRUkSLNUUFxCZ+t282clHQ+XrOT/KJS4mMjuPbEXkwbEs/x8W15Z1l6pTl0AJGhwdw2tV8AK5ejpqQY8rMPDmIHPfdv2wuF+2u+pgVDVHtvQ+6qYc7fNe83/PsRERGRo65e60Y75+YB86q03VXDuZPqcy+R5qC4pJRvNmYwZ1k6H6zawf78YjpEh/GTEYlMHxrPiO7tCAqqmH567rBuAJVWubxtar/ydmkmSkshP8svfB0qnPmFtPzsmq9pQRARVxHO2nSBTgO8x2VtZV/lz9t7e7mVLaDz6CBvmGVVsQmN83MQERGRo04bAYnUk3OO77buZc6ydN5bsZ09OYXEhIdw2vFdmD40nvF9OhASXPMCEucO66YAdzgOtchHfTnn6zGr0iNW05DG8nCWhd+aUFUYRMRWBK+oDtCh78FBrDyc+b6Hx9Z/4ZEpd1WeQwcQGum1i4iISIugQCdyBJxzrN6+j7kp25mbkk5aVh7hIUFMGXAM04fEM6nfMdr0uzFUt8jH3FneY/9Q5xwU7K8hiGUdYkhjFriDVx0tFx4LkXEVYaxdj4owVjWclT2PiIWgAH0Wyn4mjRWARUREJODMuaa3oOTIkSNdcrLWTpGmZ9OeXOYsS2dOShobducSHGRM6NuR6UPiOXVgZ2IiQgNdYstW0xDCkAjoOrRyeCs9eLGZcmFtfMErrsrwxUOEs4hYCNZ/XxERETk6zGyJc25kbeeph06kFtuz83g3ZTtzUtJZkZaNGYzq2Z6rx/fizMFdaR8dFugSWy7nIGMDbPkKtnxdfZgDKM73wtYx/asZwljNsMYQ/TcTERGRlkGBTqQambmFzFvhhbjFmzNxDgZ3i+XOMwdw9pCudI3VtgKNorQUdq32wltZiMvd5R2L7gQhkd7+aVXFJsJV7x7dWkVERESaAAU6EZ+cgmLmr9rBnJR0FqzfQ3Gpo0+naH4+5TimDelK705tAl1iy1NSBNtTKsLb1m8qVn6MTYQ+J0OPcdBjPHQ4Fla8rkU+RERERPwo0Emrll9Uwmfrdvn2ittFQXEp3eIiuXZCL6YPiWdg17aYWe0XkropyoPU5IoeuNTFUHTAO9ahLww81wtvPcZCXPeDX69FPkREREQqUaCTVqe4pJSvNnh7xc1ftYP9BcV0bBPGhaMSmT4knuFV9oqTesjfB9sWVfTApS2B0iLAoPMgGHa5rwduHLQ5pm7XTLpAAU5ERETER4FOWoXSUscS315x81ZsJyPX2ytu6qAuTB8Sz7ha9oqTOsrd4w2bLOuB27ECXCkEhUD8MBh7k9cDlzjGW2FSREREROpFgU5aLOccq9L3MTclnbkp6aRn5xMRGsSUAZ2ZlhTPpH6dtFdcfWWnVYS3rd/A7rVee0gEJIyCib/yhk8mjIKw6MDWKiIiItICKdBJi7Nxdw5zUtKZk5LOxt25hPj2ivvV6f05ZWBn2oTrY39EnIPMjb4A5wtxWVu8Y2Ex0P0ESLrQ64GLHwoh4YGtV0RERKQV0G+20iKkZ+Xx7nIvxK1M24cZjOnVnutO7M0Zg7rQTnvFHb7SUti9pvIWAjk7vWNRHbx5byfM8L53HgRB6u0UEREROdoU6KTZysgpYN6K7cxN2c6izZkADEmI5bdnDeDspHi6xEYEuMJmpqQYdqT49cB9DflZ3rG23aDXSRULmHQ8DrT6p4iIiEjAKdBJs7I/v4gPV+1kTko6X/2wh5JSx7HHtOEXpx7H9CHx9OyoeVp1VpTvrTpZ1gO3bREU5XrH2veBAdN8WwiM87YQUIATERERaXIU6KTJyy8q4ZO1u5izLJ1P1u2i0LdX3A0TezMtKZ4BXWO0V1xdFOyHbd9W9L6lLYGSQrwtBI6HYZd64a37OIjpHOhqRURERKQOFOikSSoqKWXBD3uYuyyd+at3klNQTMc24VwyujvThsQzvHucQlxtDmRW3kJge4q3hYAFe1sIjPmpF+ASx0BU+0BXKyIiIiJHQIFOmozSUsfizZnMSUnn/ZU7yMwtJCYihDMHd2H6kG6c0Lu99oo7lH3plee/7V7jtQeHe9sGTPilF+ASRkF4m8DWKiIiIiINQoFOAso5x8q0fcxJSePd5dvZ7tsr7pQBnZk+JJ6T+nUiPESrJx7EOdi7qXKA27vJOxYWA93HQNJPfFsIDNMWAiIiIiItlAKdBMQPu7y94uampLNpj7dX3EnHdeL2M/pzyoDORGuvuMpKS2HPuortA7Z8Dfu3e8ci23s9b6Ov920hMBiC9fMTERERaQ30W580uLeXpvHwh+tIz8ojPi6S26b249xh3UjLymNuSjpzlqWzeru3V9wJvTpww0Rvr7i4qFa6V9zy1+DjeyE7FWITYMpdcPx5sGN5RXjb+jXk7fXOj4mvWH2yx3hvC4EgDUUVERERaY3MORfoGg4ycuRIl5ycHOgy5Ai8vTSNO95aQV5RSXlbaLCREBfJpowDAAxJjGP6kHjOTupK57atfK+45a/B3FlQlFfRZkEQFAolBd7z9r0rwluPcRDXQ1sIiIiIiLRwZrbEOTeytvPUQycN6uEP11UKcwBFJY5te/P45WnHMW1IPD06tNK94goPwN7NkLmx4ivlJSguqHyeK4XgUPjRP7wtBNp2DUi5IiIiItL0KdBJg0rPyqu2vaTUMXNy36NcTQDk7/MWJ/EPbZmbvK/96ZXPjWx/cJgrU5gLg37c+PWKiIiISLOmQCcNJregmLCQIAqKSw86Fh8XGYCKGoFz3ly2SmHNL7wd2FP5/DadvSGTfU6Gdr2gfS/vefteENkOHh0E2dsOvk9swtF5PyIiIiLSrNUr0JnZ6cBfgWDgKefcg1WO/xT4GVAC5AA3OOdW1+ee0jTt3l/ANbMXU1BcSmiwUVRSMTczMjSY26b2C2B1h8k5yNlVpZdtY0XPW36238kGbbt5Aa3/Wb6w5gts7XrVvt/blLsOnkMXGum1i4iIiIjU4ogDnZkFA48DpwKpwGIzm1MlsL3knPun7/zpwCPA6fWoV5qgH3blcNWzi9iTU8C/rxhJbkFxtatcNimlpbAvrXJQ8x8eWZRbca4FQ1x3L6gNHuEX2np7C5SE1mNhl6QLvO9VV7ksaxcREREROYT69NCNBn5wzm0EMLNXgHOA8kDnnNvnd3400PSW1JR6Wbw5k+ueSyYkyHjlhrEMTYwDaBoBrqQYsrdWGRrp+753c8UqkgDBYdCupxfSek30vpcNkYzr7i1S0liSLlCAExEREZEjUp9A1w3wn/yTCoypepKZ/Qz4BRAGTK7pYmZ2A3ADQPfu3etRlhwt7y5P5xevpZAQF8nsq0fTvUPU0S+iuAD2bjl4eGTmRm9uWmlxxbmhUV5Q69gXjptauaetbTwEBR/9+kVERERE6qE+ga66jbAO6oFzzj0OPG5mlwC/Ba6s7mLOuSeBJ8Hbh64edUkjc87x1JebuH/eGkb0aMdTV4ykXXQjbgpemOvXs1ZleGR2KpU+duGxXq9a/DBvlcjyRUh6ewuUaP82EREREWlB6hPoUoFEv+cJQHoN5wK8AvyjHveTJqCk1PGHd1cz++vNnDm4C49cMJSI0Co9W8tfO/w5YXlZ1c9ly9wIOTsqnxvV0QtqPcZV7mVr1wui2iu0iYiIiEirUZ9Atxjoa2a9gDTgIuAS/xPMrK9zbr3v6VnAeqTZyiss4eZXljJ/9U6uPbEXd545gKCgKuFp+WuVV23M3uY9B+gzufql/jM3Ql5m5evEdPVCWt9TfHPZ/FaPjIht/DcrIiIiItIMHHGgc84Vm9lM4EO8bQuecc6tMrN7gWTn3BxgppmdAhQBe6lhuKU0fRk5BVz7XDIpqVncdfZArjmxV/Unfnxv5SX4wXv+1g1UHpFrEJvoBbSB50jjPOAAACAASURBVFTpaesJYQGYjyciIiIi0szUax8659w8YF6Vtrv8Ht9cn+tL07BpTy5XPbuIHdn5/OPS4Zw+qGvNJ2en1nDAwekP+i333x1CwhulXhERERGR1qJegU5aviVb9nLdc4sBeOn6ExjRo131J5YUw8LHqXFnithEOGFG4xQpIiIiItJKKdBJjT5YuYObX1lKl9gIZl89ml4do6s/cecqeOdnkL4Uug6F3WuhOL/ieGiktzCKiIiIiIg0qKBAFyBN07NfbWLGi0sY0LUtb80YV32YKy6ETx+Af50EWdvg/Gfhhs9g+t+8HrmyeXLTHtPG2SIiIiIijUA9dFJJaanj/nlreHrBJk4d2JnHLhpGZFg1G26nLYF3ZsKu1TD4Am9+XHQH71jSBQpwIiIiIiJHgQKdlMsvKuEXry1j3oodXDm2B3dNO57gqtsSFOXBp/fDN49Dmy5w8avQ7/TAFCwiIiIi0sop0AkAe3MLuf75ZJK37OXOMwdw3YReWNUNujd/BXNmevvGDb8STvuD9oQTEREREQkgBTpha8YBrnp2EalZeTx+yXDOSqqyLUHBfvjfPbD4KYjrAVfMgd4nBaRWERERERGpoEDXyi3blsW1sxdTXOp48boxjOrZvvIJP/wP5v7c21/uhJtg8m8hrIbVLkVERERE5KhSoGvF/rd6JzNf/o6ObcKZffVojj2mTcXBA5nw4Z2Q8hJ07AfXzofE0YErVkREREREDqJA10r9Z+EW7n5nJYO6xfL0laPoFBNecXD1HHjvVjiQARN+CRNvg9CIwBUrIiIiIiLVUqBrZUpLHX/6cC3/+nwjU/ofw98uGUZUmO9jkLML5v0SVr8DXQbDZW9A1yGBLVhERERERGqkQNeKFBSX8MvXlzM3JZ1Lx3Tn99OPJyQ4CJyD5a/BB7+GwlyY/DsYfzMEhwa6ZBEREREROQQFulYi+0AR1/8nmUWbMvnV6f2YcVIfb1uC7FR49xZYPx8SRsM5f4dO/QJdroiIiIiI1IECXSuQuvcAVz27mC0Zufz1oqGcM7QblJbCkmdh/l3gSuD0B2H0DRAUHOhyRURERESkjhToWriVadlcPXsx+UUlPH/NGMb26eBtDD5nFmz+EnpNhGmPQftegS5VREREREQOkwJdC/bpul387MXvaBcVxovXjeG4TlHw9d/hk/u8+XHTHoPhV4BZoEsVEREREZEjoEDXQr28aCu/fXsl/bvE8MxVo+icvwmenglpyXDc6XDWIxDbLdBlioiIiIhIPSjQtTDOOR756Hv+9skPnHRcJx6/aDBtFv8NvngIwtrAeU/B4PPVKyciIiIi0gIo0LUghcWl3P7mct5amsaFIxO574QSQp87FXaugOPPgzMegjadAl2miIiIiIg0EAW6FmJffhE//c8Svt6Qwa+m9GAGb2BPPwbRneCil6D/WYEuUUREREREGpgCXQuQnpXH1c8uZsPuHGZPKWHS2qsgYz0MuwxOuw8i2wW6RBERERERaQQKdM3c6vR9XDN7MaUFOXwx+H/Ef/UfiE2Ey96CY6cEujwREREREWlECnTN2JfrdzPjhe84OXQV/6/tM4St2+ZtDj7lbghvE+jyRERERESkkdUr0JnZ6cBfgWDgKefcg1WO/wK4DigGdgPXOOe21Oee4nk9eRt/fGshf27zKqcXfgRhx8LVH0CPsYEuTUREREREjpIjDnRmFgw8DpwKpAKLzWyOc26132lLgZHOuQNmNgN4CLiwPgW3ds45/vrxelZ+8gofR8ymXVEWjP85TLodQiMDXZ6IiIiIiBxF9emhGw384JzbCGBmrwDnAOWBzjn3qd/5C4HL6nG/Vq+opJQ/vv4lw1Y9wM/DvqG04/HYuW9C/LBAlyYiIiIiIgFQn0DXDdjm9zwVGHOI868F3q/poJndANwA0L1793qU1TLtzyvk+X8/wsyMvxMXkoc76TcEnXgLhIQFujQREREREQmQ+gQ6q6bNVXui2WXASOCkmi7mnHsSeBJg5MiR1V6ntdqdtokNs2/gZ0WLyGg3mOCLn4TOAwNdloiIiIiIBFh9Al0qkOj3PAFIr3qSmZ0C3Amc5JwrqMf9Wh/n2PHZk0R/fg9DXREbht9On2m/gqDgQFcmIiIiIiJNQH0C3WKgr5n1AtKAi4BL/E8ws2HAv4DTnXO76nGv1mfvZrJenUGXHV+zxI4n5oJ/cNzAIYGuSkREREREmpCgI32hc64YmAl8CKwBXnPOrTKze81suu+0h4E2wOtmtszM5tS74pautAQW/oPiv59AyPal/DViBl1mfaQwJyIiIiIiB6nXPnTOuXnAvCptd/k9PqU+1291dn+PmzMT2/YtX5YM4Y34X/LHq84gNjI00JWJiIiIiEgTVK9AJw2kpAi+fgz32Z/II4w7C2fgBl/AIz8ZQniI5suJiIiIiEj1FOgCbftyeOdnsGM5yVETuCnzYn4yaQS/PK0fQUHVLSQqIiIiIiLiUaALlOIC+Pwh+OovlES046E2v+HfGYP4w48GcemYHoGuTkREREREmgEFukDYttjrlduzjn39zueCzdPZsj+cp64cxuT+nQNdnYiIiIiINBMKdEdTYS58ch8s/Ae07cbaKc9w4ScxhAYH8eqNI0lKiAt0hSIiIiIi0owo0B0tm76AOf8HezfDyGt5v8tPufm/G0hoH8ZzV48msX1UoCsUEREREZFmRoGuseVnw0d3wZLZ0L437sp3+fe2eP74xlpG9WzHv68YSVxUWKCrFBERERGRZkiBrjF9/yHM/Tnk7ICxMymZ9Bt+/8Emnv9mLWcldeX//WQIEaHalkBERERERI6MAl1jyM2AD26HFa9BpwFw4QvkHTOU/3t5Kf9bs5MbJ/bm16f317YEIiIiIiJSLwp0Dck5WPVfmHcb5GfBSb+GCbeyJx+u/fdCVqRmce85x3PF2J6BrlRERERERFoABbqGsn8HvHcrrH0Xug6FK96BLoPYuDuHq55dzK79+fzzshGcdnyXQFcqIiIiIiIthAJdfTkHy16CD++Aonw45fcwdiYEh7BkSybXPZdMkBkvX38Cw7q3C3S1ItICFBUVkZqaSn5+fqBLETkiERERJCQkEBoaGuhSRESaPQW6+sja6i16suFj6D4Wpv8dOh4LwPsrtvPzV5cRHxfJ7KtH0aNDdICLFZGWIjU1lZiYGHr27ImZ5uJK8+KcIyMjg9TUVHr16hXockREmj0FuiNRWgrJT8P/7vF66M54GEZdB0FBADy9YBP3vbeaYYlxPHXlKNpHa1sCEWk4+fn5CnPSbJkZHTp0YPfu3YEuRUSkRVCgq4vlr8HH90J2KsR0htAYyFwPvU+GaX+Fdj0AKC113PfeGp75ahOnH9+Fv1w0VNsSiEijUJiT5kyfXxGRhqNAV5vlr8HcWVCU5z3fvwPYAcOv9MKc7y+l/KISbnl1Ge+v3ME143tx51kDCNa2BCIiIiIi0oiCAl1Ak/fxvRVhzt+GT8rDXGZuIZc+9S0frNrB784eyF3TBirMiYjIUbN582YGDRrUKNf+7LPPOPvsswGYM2cODz74YKPcR0REjowCXW2yUw/ZviUjlx//42tWpmXzxCXDufZETfAWkabl7aVpjH/wE3rd/h7jH/yEt5emNer9zjzzTLKyssjKyuKJJ54ob/cPBq3a8tfg0UFwT5z3fflrga6ozqZPn87tt98e6DJERMSPAl1tYhNqbF+2LYvznviarAOFvHT9GM4Y3PXo1iYiUou3l6Zxx1srSMvKwwFpWXnc8daKRg118+bNIy4u7qBAdzQVFxcH5L61KhvGn70NcN73ubMaJNQVFxdz5ZVXkpSUxPnnn8+BAwe49957GTVqFIMGDeKGG27AOQfAY489xsCBA0lKSuKiiy4CIDc3l2uuuYZRo0YxbNgw3nnnnYPuMXv2bGbOnAnAVVddxaxZsxg3bhy9e/fmjTfeKD/v4YcfZtSoUSQlJXH33XfX+72JiEjNNIeuNlPuqjyHDiA0khX9b+aiJ7/hmJgIZl89it6d2gSuRhFptX4/dxWr0/fVeHzp1iwKS0orteUVlfCrN5bz8qKt1b5mYHxb7p52fI3XfOihh4iIiGDWrFnccsstpKSk8Mknn/Dxxx/z7LPPsmDBApKTk7n99tvZsGEDQ4cO5dRTT+Wss84iJyeH888/n5UrVzJixAheeOGFGhfI6NmzJ1deeSVz586lqKiI119/nf79+5OZmck111zDxo0biYqK4sknnyQpKYl77rmH9PR0Nm/eTMeOHTnttNN4++23KSkpYeXKldx6660UFhbyn//8h/DwcObNm0f79u3r8FM+DO/fDjtW1Hw8dTGUFFRuK8qDd2bCkueqf02XwXBG7cMc161bx9NPP8348eO55ppreOKJJ5g5cyZ33XUXAJdffjnvvvsu06ZN48EHH2TTpk2Eh4eTlZUFwP3338/kyZN55plnyMrKYvTo0ZxyyimHvOf27dtZsGABa9euZfr06Zx//vnMnz+f9evXs2jRIpxzTJ8+nS+++IKJEyfW+h5EROTwqYeuNkkXwLTHIDYRMIhN5Iv+v+OcL+Lp16Utb900TmFORJqsqmGutva6mDhxIl9++SUAycnJ5OTkUFRUxIIFC5gwYUL5eQ8++CB9+vRh2bJlPPzwwwAsXbqUv/zlL6xevZqNGzfy1VdfHfJeHTt25LvvvmPGjBn8+c9/BuDuu+9m2LBhLF++nD/+8Y9cccUV5ecvWbKEd955h5deegmAlStX8tJLL7Fo0SLuvPNOoqKiWLp0KWPHjuX5558/4p/BEasa5mprPwyJiYmMHz8egMsuu4wFCxbw6aefMmbMGAYPHswnn3zCqlWrAEhKSuLSSy/lhRdeICTE+7fd+fPn8+CDDzJ06FAmTZpEfn4+W7dWH/rLnHvuuQQFBTFw4EB27txZfp358+czbNgwhg8fztq1a1m/fn2935+IiFRPPXR18HbJeB4ueIz0/DyiXQg5O4s5ZUBnHrt4KFFh+hGKSOAcqicNYPyDn5CWdfDCTt3iInn1xrFHdM8RI0awZMkS9u/fT3h4OMOHDyc5OZkvv/ySxx57jAceeKDG144ePZqEBG8o+9ChQ9m8eTMnnnhijeefd9555fd86623AFiwYAFvvvkmAJMnTyYjI4Ps7GzAm+MVGRlZ/vqTTz6ZmJgYYmJiiI2NZdq0aQAMHjyY5cuXH9H7P6TaetIeHeQbbllFbCJc/V69bl21p9PMuOmmm0hOTiYxMZF77rmH/Px8AN577z2++OIL5syZwx/+8AdWrVqFc44333yTfv36VbpOWVCrTnh4ePnjsuGczjnuuOMObrzxxnq9HxERqRv10NWi6vyTnIJigoOMMwd1UZgTkSbvtqn9iKyyH2ZkaDC3Te1XwytqFxoaSs+ePXn22WcZN24cEyZM4NNPP2XDhg0MGDDgkK/1DwDBwcG1znUrO9//3LLg4K8szERHR9d4v6CgoPLnQUFBgZlnN+UuCI2s3BYa6bXX09atW/nmm28AePnll8uDcseOHcnJySmf41ZaWsq2bds4+eSTeeihh8jKyiInJ4epU6fyt7/9rfznu3Tp0iOqY+rUqTzzzDPk5OQAkJaWxq5du+r79kREpAb1CnRmdrqZrTOzH8zsoGWvzGyimX1nZsVmdn597hUoD3+4jryikkptJaWO//fR9wGqSESk7s4d1o0HzhtMt7hIDK9n7oHzBnPusG71uu7EiRP585//zMSJE5kwYQL//Oc/GTp0aKVeopiYGPbv31/Pd1D9vV988UXAWzmzY8eOtG3btsHv0yiqGcbPtMe89noaMGAAzz33HElJSWRmZjJjxgyuv/56Bg8ezLnnnsuoUaMAKCkp4bLLLmPw4MEMGzaMW265hbi4OH73u99RVFREUlISgwYN4ne/+90R1XHaaadxySWXMHbsWAYPHsz555/fKJ8DERHxHHEXk5kFA48DpwKpwGIzm+OcW+132lbgKuCX9SkykNKrGap0qHYRkabm3GHd6h3gqpowYQL3338/Y8eOJTo6moiIiErz5wA6dOjA+PHjGTRoEGeccQZnnXVWg9z7nnvu4eqrryYpKYmoqCiee66GxUSaqqQLGiTA+evZsyerV68+qP2+++7jvvvuO6h9wYIFB7VFRkbyr3/966D2SZMmMWnSJMBb2fKqq64CvBUv/ZX1yAHcfPPN3HzzzYfxDkRE5EhZdUNX6vRCs7HAPc65qb7ndwA45w6aPGFms4F3nXNvVD1WnZEjR7rk5OQjqquhHWr+yVe3Tw5ARSLS2q1Zs6bWoY0iTZ0+xyIih2ZmS5xzI2s7rz5DLrsB/jO7U31tR8TMbjCzZDNL3r17dz3KaliNMf9ERERERESkIdRnVY/qNg46su4+wDn3JPAkeD10R3qdhlY2TOnhD9eRnpVHfFwkt03t1+DDl0REWqsf/ehHbNq0qVLbn/70J6ZOnRqgikRERJqP+gS6VCDR73kCkF6/cpqmxph/IiJSH865Gjfkbm7++9//BroEOcqOdLqHiIgcrD5DLhcDfc2sl5mFARcBcxqmLBERqUlERAQZGRn6pViaJeccGRkZREREBLoUEZEW4Yh76JxzxWY2E/gQCAaecc6tMrN7gWTn3BwzGwX8F2gHTDOz3zvnDr0LroiIHFJCQgKpqak0pfnGIocjIiKifIN5ERGpnyNe5bIxNaVVLkVERERERI62o7HKpYiIiIiIiASQAp2IiIiIiEgzpUAnIiIiIiLSTDXJOXRmthvYEug6qtER2BPoIqTF0udLGpM+X9KY9PmSxqTPlzS2pvoZ6+Gc61TbSU0y0DVVZpZcl4mJIkdCny9pTPp8SWPS50sakz5f0tia+2dMQy5FRERERESaKQU6ERERERGRZkqB7vA8GegCpEXT50sakz5f0pj0+ZLGpM+XNLZm/RnTHDoREREREZFmSj10IiIiIiIizZQCnYiIiIiISDOlQFcHZna6ma0zsx/M7PZA1yMth5klmtmnZrbGzFaZ2c2BrklaHjMLNrOlZvZuoGuRlsfM4szsDTNb6/t/2dhA1yQth5nd4vv7caWZvWxmEYGuSZovM3vGzHaZ2Uq/tvZm9pGZrfd9bxfIGo+EAl0tzCwYeBw4AxgIXGxmAwNblbQgxcCtzrkBwAnAz/T5kkZwM7Am0EVIi/VX4APnXH9gCPqsSQMxs27ALGCkc24QEAxcFNiqpJmbDZxepe124GPnXF/gY9/zZkWBrnajgR+ccxudc4XAK8A5Aa5JWgjn3Hbn3He+x/vxfhHqFtiqpCUxswTgLOCpQNciLY+ZtQUmAk8DOOcKnXNZga1KWpgQINLMQoAoID3A9Ugz5pz7Asis0nwO8Jzv8XPAuUe1qAagQFe7bsA2v+ep6BduaQRm1hMYBnwb2EqkhfkL8CugNNCFSIvUG9gNPOsb1vuUmUUHuihpGZxzacCfga3AdiDbOTc/sFVJC9TZObcdvH9oB44JcD2HTYGudlZNm/Z6kAZlZm2AN4GfO+f2BboeaRnM7Gxgl3NuSaBrkRYrBBgO/MM5NwzIpRkOV5KmyTeX6RygFxAPRJvZZYGtSqTpUaCrXSqQ6Pc8AXX3SwMys1C8MPeic+6tQNcjLcp4YLqZbcYbLj7ZzF4IbEnSwqQCqc65spEFb+AFPJGGcAqwyTm32zlXBLwFjAtwTdLy7DSzrgC+77sCXM9hU6Cr3WKgr5n1MrMwvMm4cwJck7QQZmZ4c0/WOOceCXQ90rI45+5wziU453ri/b/rE+ec/nVbGoxzbgewzcz6+ZqmAKsDWJK0LFuBE8wsyvf35RS06I40vDnAlb7HVwLvBLCWIxIS6AKaOudcsZnNBD7EW13pGefcqgCXJS3HeOByYIWZLfO1/cY5Ny+ANYmIHI7/A170/aPnRuDqANcjLYRz7lszewP4Dm9V6KXAk4GtSpozM3sZmAR0NLNU4G7gQeA1M7sW7x8RfhK4Co+MOafpYCIiIiIiIs2RhlyKiIiIiIg0Uwp0IiIiIiIizZQCnYiIiIiISDOlQCciIiIiItJMKdCJiIiIiIg0Uwp0IiLSYplZiZkt8/u6vQGv3dPMVjbU9URERI6E9qETEZGWLM85NzTQRYiIiDQW9dCJiEirY2abzexPZrbI93Wsr72HmX1sZst937v72jub2X/NLMX3Nc53qWAz+7eZrTKz+WYWGbA3JSIirZICnYiItGSRVYZcXuh3bJ9zbjTwd+Avvra/A88755KAF4HHfO2PAZ8754YAw4FVvva+wOPOueOBLODHjfx+REREKjHnXKBrEBERaRRmluOca1NN+2ZgsnNuo5mFAjuccx3MbA/Q1TlX5Gvf7pzraGa7gQTnXIHfNXoCHznn+vqe/xoIdc7d1/jvTERExKMeOhERaa1cDY9rOqc6BX6PS9DcdBEROcoU6EREpLW60O/7N77HXwMX+R5fCizwPf4YmAFgZsFm1vZoFSkiInIo+pdEERFpySLNbJnf8w+cc2VbF4Sb2bd4/7h5sa9tFvCMmd0G7Aau9rXfDDxpZtfi9cTNALY3evUiIiK10Bw6ERFpdXxz6EY65/YEuhYREZH60JBLERERERGRZko9dCIiIiIiIs2UeuhEROSoMLOeZubMLMT3/H0zu7Iu5x7BvX5jZk/Vp14REZHmQIFORETqxMw+NLN7q2k/x8x2HG74cs6d4Zx7rgHqmmRmqVWu/Ufn3HX1vbaIiEhTp0AnIiJ1NRu43MysSvvlwIvOueKjX1LrcqQ9liIi0nIp0ImISF29DbQHJpQ1mFk74Gzged/zs8xsqZntM7NtZnZPTRczs8/M7Drf42Az+7OZ7TGzjcBZVc692szWmNl+M9toZjf62qOB94F4M8vxfcWb2T1m9oLf66eb2Sozy/Ldd4Dfsc1m9kszW25m2Wb2qplF1FBzHzP7xMwyfLW+aGZxfscTzewtM9vtO+fvfseu93sPq81suK/dmdmxfufNNrP7fI8nmVmqmf3azHYAz5pZOzN713ePvb7HCX6vb29mz5pZuu/42772lWY2ze+8UN97GFrTfyMREWn6FOhERKROnHN5wGvAFX7NFwBrnXMpvue5vuNxeKFshpmdW4fLX48XDIcBI4Hzqxzf5TveFm9vuEfNbLhzLhc4A0h3zrXxfaX7v9DMjgNeBn4OdALmAXPNLKzK+zgd6AUkAVfVUKcBDwDxwAAgEbjHd59g4F1gC9AT6Aa84jv2E995V/jew3Qgow4/F4AueEG6B3AD3t/dz/qedwfygL/7nf8fIAo4HjgGeNTX/jxwmd95ZwLbnXP++/SJiEgzo0AnIiKH4zngJ2YW6Xt+ha8NAOfcZ865Fc65UufccrwgdVIdrnsB8Bfn3DbnXCZeaCrnnHvPObfBeT4H5uPXU1iLC4H3nHMfOeeKgD8DkcA4v3Mec86l++49F6i218o594PvOgXOud3AI37vbzRe0LvNOZfrnMt3zi3wHbsOeMg5t9j3Hn5wzm2pY/2lwN2+e+Y55zKcc2865w445/YD95fVYGZd8QLuT51ze51zRb6fF8ALwJlm1tb3/HK88CciIs2YAp2IiNSZL6DsBs4xs97AKOClsuNmNsbMPvUNB8wGfgp0rMOl44Ftfs8rhR0zO8PMFppZppll4fUu1eW6Zdcuv55zrtR3r25+5+zwe3wAaFPdhczsGDN7xczSzGwfXkgqqyMR2FLDXMJEYEMd661qt3Mu36+GKDP7l5lt8dXwBRDn6yFMBDKdc3urXsTXc/kV8GPfMNEzgBePsCYREWkiFOhERORwPY/XM3c5MN85t9Pv2EvAHCDRORcL/BNvmGJttuOFkTLdyx6YWTjwJl7PWmfnXBzesMmy69a2oWo63vDEsuuZ715pdairqgd890tyzrXFG8JYVsc2oHsNC5dsA/rUcM0DeEMky3Spcrzq+7sV6AeM8dUw0dduvvu095/XV8Vzvpp/AnzjnDuSn4GIiDQhCnQiInK4ngdOwZv3VnXbgRi8HqJ8MxsNXFLHa74GzDKzBN9CK7f7HQsDwvF6BovN7AzgNL/jO4EOZhZ7iGufZWZTzCwULxAVAF/XsTZ/MUAOkGVm3YDb/I4twgumD5pZtJlFmNl437GngF+a2QjzHGtmZSFzGXCJb2GY06l9iGoM3ry5LDNrD9xddsA5tx1vkZgnfIunhJrZRL/Xvg0MB27Gt5CNiIg0bwp0IiJyWJxzm/HCUDReb5y/m4B7zWw/cBdemKqLfwMfAinAd8BbfvfbD8zyXWsvXkic43d8Ld5cvY2+VSzjq9S7Dq9X6m/AHmAaMM05V1jH2vz9Hi8QZQPvVamzxHftY4GtQCre/D2cc6/jzXV7CdhPxYqh4IWraUAWcKnv2KH8BW8O4B5gIfBBleOXA0XAWrzFZH7uV2MeXm9nL//aRUSk+TLnahupIiIiIi2Fmd0FHOecu6zWk0VEpMnTBqUiIiKthG+I5rV4vXgiItICaMiliIhIK2Bm1+MtmvK+c+6LQNcjIiINQ0MuRUREREREmin10ImIiIiIiDRTTXIOXceOHV3Pnj0DXYaIiIiIiEhALFmyZI9zrlNt5zXJQNezZ0+Sk5MDXYaIiIiIiEhAmNmWupynIZciIiIiIiLNVJ0CnZmdbmbrzOwHM7u9muM/NbMVZrbMzBaY2UBfe08zy/O1LzOzfzb0GxAREREREWmtah1yaWbBwOPAqUAqsNjM5jjnVvud9pJz7p++86cDjwCn+45tcM4NbdiyRUREREREpC49dKOBH5xzG51zhcArwDn+Jzjn9vk9jQa0F4KIiIiIiEgjq0ug64a3EWmZVF9bJWb2MzPbADwEzPI71MvMlprZ52Y2oaabmNkNZpZsZsm7d++uY/kiIiIiIiKtV10CnVXTdlAPnHPucedcH+DXwG99zduBZDMNqQAAIABJREFU7s65YcAvgJfMrG11N3HOPemcG+mcG9mpU62rc4qIiIiIiLR6dQl0qUCi3/MEIP0Q578CnAvgnCtwzmX4Hi8BNgDHHVmpIiIi0qQsfw0eHQT3xHnfl78W6IpERFqdugS6xUBfM+tlZmHARcAc/xPMrK/f07OA9b72Tr5FVTCz3kBfYGNDFC4iIiIBtPw1mDsLsrcBzvs+d5ZCnYjIUVbrKpfOuWIzmwl8CAQDzzjnVpnZvUCyc24OMNPMTgGKgL3Alb6XTwTuNbNioAT4qXMuszHeiIiIiBxFH98LRXmV24ryvPakCwJTk4hIK1RroANwzs0D5lVpu8vv8c01vO5N4M36FCgiIiJNTGGur2euGtmp4BxYdVPwRaSxvL00jYc/XEd6Vh7xcZHcNrUf5w47aB1DaYHqtLG4iIiICKWlsOwl+NvIQ5zkYPZZsPmro1aWSGv39tI07nhrBWlZeTggLSuPO95awdtL0wJdmhwFCnQiIiJSu01fwJMnwdszoG1XmPgrCI2sfE5oJCRdDBkbYPaZ8Pw5sG1RYOoVaUUe/nAdp5Z8zoKwWWwMv4QFYbM4teRzHv5wXaBLk6OgTkMuRUREWgMNWarGnh/go7tg3XsQmwg/fhqOPw+CgqBjX2/OXHYqxCbAlLu8+XNFeZD8DCx4FJ4+FY49FU7+DXQbHuh3I83J8teq/3y1Rs6BK4XSEigtBlfiPXalHCgoYPK+t/lN6EtEWhEACbaHB0Of4vZ9sHjzUEb2aIdpGHSLZc4dtKVcwI0cOdIlJycHugwREWlFyoYs5RWVlLdFhgbzwHmDW2eoO5AJn/8JFj8FIZEw4RY44aaDe+UOpTAXFj0JX/0V8vZCv7Pg5Dugy+DGq1tahrJVVP0X3gkOhxN/Dr0nVQk2pRUB55BtJRWhyPnaD6vN/7r1aTuC2l3pEf0YM1wMJxc8wrHdu3HjSX04dUBngoIU7JoLM1vinDvUGHfvPAU6ERFpzTJzC1m0KYNbX08ht6DkoONtI0J44tIRDE6IJTYyNAAVHmXFBV4I++JhKNgPw6/0etfaHHPk18zfB9/+E77+OxRkw8BzYNJv4Jj+DVe3tCyPDIR9R3n+lwWBBUNQMASF+B4fQZv52uvVFuzVU95Wdi+vbXNmPvPX7CFtXxFd20VzY84T1BTTSgliVVBfPi48ng0xoznxpKmcM6IHEaHBR/XHK4dPgU5ERKQaGTkFLNqUycKNGSzcmMm6nfvr/NrenaIZmhjH0MQ4hiTE0b9rDOEhLeSXIudgzRxveOXezXDsKXDafXDMgIa7R14WfPM4LPwHFObA4PPhpNuh47ENdw9p3vb84IX/xf+u4QSDK95unKDUDIYkbtidwwPz1vK/NTvpFhfJr07vx7SkeIL+Orj6lWejj4GRV+N++BjSvsMoZZ+LYknQYKzvFIaf/GPadtWfv6ZKgU5ERAQvwH3rC3Df+gW4yNBgRvZsxwm9O3BC7/b830tLSc/OP+j1XWMjeOj8JFK2ZbFsWzbLtmWxJ6cAgLDgIAbGt/UCXmIsQxLi6NkhuvkNaUpdAvPvhK3fwDED4bQ/eIGusRzIhK8fg2//BcX5MORimHgbtO/VePeUpss52PipF/TXz4fgMC9kFR04+NzYRLhl5dGvMcAycwt57OP1vLBwCxGhwdx0ch+uGd+ropetuiGqoZEw7bGKeYcHMnGbvmDn0nmEbPqUjiW7vGuHJxDe/xSiB5wGPSdARNuj/O6kJgp0IiLSKu3JKeDbjb4AtymD73fmAFUDXAcGd4slLKRisee6zqFzzpGenU/KtixfyMtiRVo2Bwq917WNCGGIXy/ekMQ4OsWEH6V3f5iytsHHv4cVr0N0J5j8Wxh6GQQfpTXTcnbDV3/x5umVFsPQS71gF5d4dO4vgVV4AJa/6vXI7V7r9SaNuhZGXgMbP6s9oLQCBcUlPPf1Zv72yQ/kFhRz8eju3HLqcXRsU83/Uw5nERnnWL9mKSmf/Zd2OxZwgq0i2gpwFowljoY+U6DPZIgf6vViSkAo0ImISKuwe38B327KKA9x63d5AS4qLJiRPdtzQu/2jOnVgaSEWEKDD71bz5GucllS6li/a395L17KtizW7dxPSan3d2y3uMhKvXiDusUSHR7Ahabz93krUC58wns+dqa32ER4TGDq2bcdFjwCS2Z7vTUjroQJt0Lb+MDUI40rO80bUrlktrdYTpckb8GdQedBiF9QacWrXDrneH/lDh54fw3bMvOY1K8TvzlzAMd1bvg/o9syDzD7i+9Zv+QTRrtlnB21hh6F6zEcRMR5i9D0mex96R9bjioFOhERaZHKAlzZHLgffAEuujzAdWBM7/YM7lZ7gGtMBwqLWZW+r7wXLyU1i22ZXm9DkMFxnWN8Ic/ryTuucxtCGrvekmJY+jx8+kfI3Q1JF8Lk3zWdX9KyU+GLP8PS/3jzm0ZdCyfeUr8FWaTp2LYYvv0HrHobcND/bDhhBnQf2yzmrx0tS7fu5f731pC8ZS/9Osdw51kDmHhcp0a/797cQv6zcAuzv94MuXu4pNMmLuqwnm4ZC7H96d5JHY+rCHc9xkN4m0avqzVToBMRkRZh1/788t63hRsz2LA7F/AC3KhevgDXqz2DAhzg6mJPTgHLUyt68VJSs8g64O0bFREaxOBusZVCXkK7yIbbO2r9/2D+b2H3Gug+DqbeB91GNMy1G9rezfD5w5DystdjM/p6GHczRHcIdGVyuEqKYPU73vy4tGQIj4Xhl8PoG6Bdj0BX16Sk7j3AQx+sY05KOh3bhHPracdxwchEgo/ynNy8whLe+C6Vf3+xka2ZB+jVIYpbh8HUiJWEbv4MNn8FxXkQFArdT4A+J3tDNLskeQvRSINRoBMRkWZp1758Fm6qCHAbfQGuTXgIo3q2Y4xvDtyg+LaN36PVyJxzbMk4QEqqrxdvWxYr0/dRWOztOdUhOqxiPl5iHEMSYomLCju8m+xc7QW5DR9Du15w6r0wYFrz6BHJ2ODthbf8NQiLhjE/hXEzIbJdoCs7Iq1q4/oDmbDkWVj0FOxPh/Z9vN64IRerV6eK/flFPPHZBp5esAkDrp/Qm59O6kObQA7LxhtK/sHKHfzz8w2sSMumY5swrh7fi8tGdCZ2zxLY8In3tWOF94KoDtD7ZF8P3skaMt0AFOhERKRZ2Lkvv3z45LebDg5wZYuYHN8CAlxdFBaXsm7HfpalZpUvvPLD7hzK/rru2SGqIuAlxjGwa9vq95PK2QWf3g/fPe/NjTvp1zDqegg5zEDYFOxeB589AKv+C+FtYezPvHAQERvoyuqs1Wxcv2uN1xu3/FVvBdPeJ3vz4449Rb03VRSXlPLK4m08+tH3ZOQW8qNh3bhtaj/i4yIDXVolzjm+2ZjBvz7fyOff7yYqLJiLR3fnmhN70S0uEvbv9BaxKQt4ud7qmXQaAMdO8cJd93EQFhXQ99EcKdCJiEiTtCM7v3wO3LcbM9m4xwtwMeEhviGU3jDKgV1bR4Cri335RaxMzS4Pecu2ZbFzn7d1QkiQMaBr2/KQN6xrGL3WP0/QV496v1CPuh5O+hVEtQ/wu2gAO1d58//Wvust1jB+Foy+scn1+OQXlbAnp4A9OYVk5BSQkVPIfe+tZl9+8UHndouL5KvbJwegygZUWgo/fOQtsrPxMwiJgCEXeT2qDbmPYQvhnOOz73fzx/fWsH5XDqN7tue3Zw8gKSEu0KXVas32fTz5xUbmpKRjwPQh8dxwUm/6d/FtdeCc9+d0wyfeqIAt30BJAQSHQ4+xFfPvOg9qHqMEAkyBTkREmoQd2fnlWwgs3JjJprIAFxHCaN8iJif07sDA+LZHfa5Ic7YjO798sZWUbVmsSN3L5KIv+FXoq3SzDBZHjGNZv1voflwSQxPj6Nw2ItAlN5z0ZV6wW/8hRHX0VugceW2j9QCUljqy84oqQlpuAXv2F5CRW8ienEL25BR4wS23kD37C8gtLKn9on4W3TmFY2Ka4X+fghxY9pK37UDmBoiJ9+Y7jriqZfwDQiNYu2Mf97+3hi/X76FHhyjuOGMAU4/v3HBzZY+S1L0HeGbBZl5ZvJUDhSVM6teJGyf24YTe7Su/l8IDsPVr2PCpF/J2rfbao4+pCHd9TtbCRzVQoBMRkYDYnp1X3vu2cGMGmzO8zYFjIkIY06siwA3oqgDXYLZ8jfvwTiz9O/bGDuTNTjN4Z29v1mzfR7Fv64QubSP8hmrGMrhbLDERoQEuvJ62LYbP/uj9otimM5z4Cy9MhNYejvKLSsjI9XrQKnrTKoez3b7QlplbWL4Fhb8gg/bRYXRsE06HNmF0iA4vf9yx7HlMOB2iw7jwX99Uu3E9eL2spwzozMVjujPh2I5Nf2P6vZth0b/hu/9AQTYkjPJ64waeA8HN/DPVSHbtz+fRj77n1cXbiIkIZdaUvlx+Qo9Ke2E2R1kHCnnBtzLmnpxChiTEcuNJfZh6fJfq//++L70i3G38FA5keO2dB/sWV5nsrXpahz/DrYECnYiIHBXpWXle79uGTBZuymCLL8C1jQhhdK8O5UMoFeAaQcYG+N/dsGau1ztyyt0w+ILyuUr5RSXlWyeU9eSVBWwzOLZTm/KQNzQxjn5dYpr8SqHV2vI17tP7sc0LKIruyrZBN7G26znsyXPs2V/AnvLgVjEEcn/BwcMfwZvX1jGmLJxVCWsx4XSMDqNDG+9YXFRYnT/TNc2h+/mpfcnIKeSNJalk5haS0C6Si0YlcsHIRI5pSr2qzsGWr71tB9a+BxbkBbgxMyBxVKCra7LyCkt4esFG/vHZBgqKS7libE9mTTn28Bc3auLyi0p407cy5uaMA/ToEMX1E3pz/oiE6uf4gjdUd8fyirl3WxdCaRGERELP8RU9eJ36t9rhmQp0IiLSKNKz8spXoFy4MZOtmV5AiI0MZXR5D1x7+ndRgGs0eXu9Zf0XPQnBYd5ebWN/Vqchh3tzC33hLrt8dc3M3EIAwkOCOD6+LUMT2zEk0dtCoXv7qIANBysoLiGjrOfMb5hjWSjb7fueket9H8VKbg15nZFB35PqOvJY8Y/4b+kE2kZF+XrNwunQxusx6+TrOevgC2ydfN+jwhpvZcFDrXJZUFzC/FU7eXnRVr7ekEFwkHHKgGO4eHR3JvTtFLg/S8UFsPItb37cjuXeCqMjroZR10FsC1rMpYGVljreSUnjoQ/WsT07n6nHd+b2MwbQq2N0oEtrVCWljvmrvJUxU1Kz6RAdxlXjenL52B61h9iCHNjyVUXA2/O91x7TtSLc9T65VW1fokAnIiINIi0rj4UbfAFuU0b55tixkaGVhlD27xLT9IeKNXfFhZD8tLeUf14WDLsMJv8WYroc8SWdc6TuzSvfNiElNYsVadnkF3lbJ7SLCi3fF29oYhxJCbF0aBMOHP4y/M459uUVs8cXwMqGN1bMQ/PNT/M931/NIiLg7dlXFs68HrMwv+ehHLt/Eb1X/IXI3Sm4dr2wSbfz/9m777iq7vuP46/DRkBQhoMhIIo7rmiMe4WMJjGjSTOapM2eTdLYJk2a1aS1xqb9pUmaPdpMs4xmqXHEkTjjHjhAGQ5ABNlw7/3+/jgIqKCoyGW8n48HD+Ccc+/5gKj3zff7/Xzp+0vwqGOkoIlJzSnioxVpfFI5ahcZUjlqd3Z0462FLMyCVW/ByjftroXhPezOon2vUrfCE1iecoBnv9nC+ox8+kYG8+hFPTknvvWEELD/ri9PzeXVH3ayINnujHn12dHcPCKOqHb1/PnJS7enZe6YZzfbKc0DLOh0VnXAix7aPDv31pMCnYiInJKMg8Usq1z/trxGgAtpUx3ghsYpwDUqY+xpbnMft5tPxI+B856Bjn3PyO0qnC627S+wR/Equ2puyyqo2johur0/YQG+bNyTT4Wz+nWEj6cHVw6KJDYs4IiQVjOs1bz+MMuCdm18KkfM7HAWVjmSFlZjJK16FM3zxKOGxsC27+ytG/ZtgNBuMOZh6H15s2mfX+ZwMnezPWq3dIc9ajeuRwTXDolhVPczNGq3dx0sewU2fgrOcuiWZAe5+DGtdtpbfaXmFDHl2y3M3rSfTsF+9i84+ke2+n8nt+6r7Iy5dg8GuLhfJ24b1ZVendvW/0lcTrsZ0uHRu4wV4HKAdwDEjqjcHmEchCa0qJ9TBToREamX9NziyvBmh7iMg3aAa9fGm6GVa+CGxoeS2EEBzi32rIXZj8LuJRCWaAe5bhMb/UVLYZmDjZn5VaN4szfuo5ZsVsXHy4PwyrVmoUeFs+rGIfb79m18ztwWFS6Xvc3Bwr/ZHfYiesGYR5rP5uqVduUU8dHKdD5dnU5OYTmdg/24+uwYrjo7ik7Bp7lvmcsJyd/Y+8ftXmq/SB5wnb0lRFhCw3wBLVhecTkvzNvB/5btwtvTgztHd+WWkfH4+zSPEeHGsievhLeWpPLhijSKyp2M6h7OHaPiGdY19OSndZcegl2LqwNebop9PDi6urlK3Ohm321VgU5ERI6ZEvfQed0ZHNu+av3bspQDZOZVBzh79K0953QNpXuEApxb5WfC/L/Auo/sFyVj/wQDbwLPM7fG62TEPfw1tb2CsIANTyURUJ9RtMbkcsGmz2HhFDiwHTr2s7+n3c9vVsGu3OHi+y32qN3i7Tl4WDCuh73WbkxixMmN2pXm250qV7wKeWkQHANDb7en8vo3/T3R3K3c4eJ/y3bzwrztFJRWcNXgaB6c2L1pNbNpgvKLK3hv+W7eXrqLnMIy+kYGc/voeM7v3fHUf7GTm1o9PTN1EZQdshv3dB5YPT0zavCxXVjXT4d5T0N+BgRHwfjHod9Vp/9FNhAFOhGRVsYYQ4XTUFLhpKzCycx1e3hudjJlDlfVNRZUvQhvH+Bjj77F2WvgukUEKsA1BWWFsPT/4Md/g3HCOXfByAfBL9jdlR1h+JT5Vb8MqKnJb5TtdNjTCRdOgYOpEDnIDnZdxzerYAeQdqCYj1amMX1VBjmFZXQK9uOqwdFcfXY0nUOOM2p3YKe9d9zaD6C8ELoMt7cdSLywyfzCoCkzxjB7036mfLuFXQeKGdktjD9d2JOenU5iCqFQWuHkizWZvL4ohZScImLat+HWkXFcOSj69EY3nQ7IXF09epe5CowLfIIgbpQ9gpcwHjJWwaz7oKLGv2Pe/nDxC00m1CnQiUiLdLJNGJoCh9NFSYWT0goXpRVOSiucVZ+XVDgpKXdS5rDf2+eOvu7IY0c8vvzIY7VslXWMYH9vPrljGN0iApvWCEpr53LC2vdh/jNQuB/6XAHjn4B2XdxdWa3qasP/t8v7Nvm/kwA4K2Ddh3a30Pw0iD7HDnbxo91d2UmrcLqYt2U/H6xIZ/H2bCxgTKK91m5MYrg96mGM3Vhi+SuwbbY9UtHnCjvIde7v7i+h2diQkc9fvt7MitRcEiICefSinozpHq5/S0+D02WYu3k/r/ywk7XpebQP8OHGYbHcMKwL7QIaoOFJyUF71G7nfNgx3/77DnaTJJfz2OuDo+GBjad/3wagQCciLU5DvoB0uQyllSHqeGGr6lj5sccOX1tX2CqtfG5HfVJWLXy9PPD38cTPy9N+7+2Jn7cH/t72x/7envge9bm/j2fV4x79ovb/kCwgdcpFp1STnCE7F8Ccx2D/RogaAkl/bRZ7ezXHX7Acw1EOa/4Hi6ZBwR6IHQljH4Uuw9xd2SlJzy3m45XpfLwqneyCMroEWTwWs4ExeZ/hfSAZAsJh8M0w+LcQ1MHd5TYbe/JKmDY7mc/XZBIa4MP9E7tzzdnRZ27tZytkjGHlroO8+sNO5m3Nwt+7ujNmdPsG6qxqjL3ebud8+OahOi6y4Mm8hrnfaVKgE5EWp64pXoG+Xlw1OLpqqmHJ0cGq5rFyJ6UOF+U1piGeDB9PD/y8PewAVRm2/Hw88T98zPtw8KoOX1XHfDzxOyakHfm4w+99vTxOe/pjs50S15pkbYW5f4btcyAkBiY8Bb0va3ZT/1qEilJY/Q4s/ofdpr/rODvYRZ3wtVSTVHEwg/TZLxC+7UOCXIfY5OrCj+FXETv6Bsb2jlIQqafCMgev/rCT1xalYICbR8Rx55iutPXzPuFj5dRt21/Aa4tS+HJtJi4DF/XtxG2j4ukT2YBTz//ZB/LTjz2uEbqGoUAnIkcrrXDS48/f1Xk+yNcLX29P/H08qsNSfcJWjeuqwlbVtcc+rjltlN3sp8S1ZIXZdtfF1e+ATwCMesjuKOitZgpuV15s7/W35J9QfMBu2z/2T81nWmLGKrtb5eYZ9rqhxAvJ6vNb3suM5OPVGew/VEZEkC9Xnx3NVYOjG27ko4VxugyfrEpn2pxt5BSWcclZnZmclKjvVyPbm1/C20t38cHyNArLHIzsFsbto7oyPOEUOmMebf10raE7kxToROSw3KJy3lu2m//+tIucwvJar9GIU91axJS4lqSiFJb/BxY/D+VF9rS3MQ9DQJi7K5OjlRXa3R+XvmBvaNzjF/Z2Bx37uLuyYzkrYMtMO8hlrATftjDwBhhyK7SLrbrM4XSxIDmbD5bvZuG2bABGdQvnmiExjO8ZgbdG7QBYvD2bZ7/ewtZ9BQyMCeGxX/RiYEw7d5fVquWXVPDB8jTeWppKdkEZvTu35fbRXbmwz2l0xgR1uTyTFOhEJCW7kDeXpPLZzxmUVrgYmxhOz05teXtpKiUV1dMlNeIkzYIxsPEz+P4pe0F+9/Nh4l8gvLu7K5MTKc23g9JPL9mt0HtfZge78ER3VwbFufYo74rX7fV/7eNh6J3Q/xrwDTruQzPzSvh4ZTrTV6az71Ap4UG+XDU4il+dHdNqR6G27y/g2W+2sDA5m+j2/jx8fk8u7NtRDU+akDKHkxlrMnl1UQop2UVEtfPn1pHx/HJwFG18Wl6HVgU6EWl2jDEsT83ljcUpzNuahbenB5cPiOTmEXF062C/ONGI00lq4r99bBXSV8DsP9kjJx36QtIzED/G3VXJySo5CD++aHeJrCiGvr+E0X+E0K6NX0vWVnukd93H4Cixf56G3gndzgOPkxutcDhdLEzO5sMVaSxIzsIAIxLCuHZIDBN6dWgVo3Y5hWX8c+42PlqZThsfT+4dl8CN58bi66WNwZsql8vw/Ra7M+bPaXm0a+PNDZWdMUMDfd1dXoNRoBORZqPC6eKbDXt5Y3EqGzLzaR/gw/XndOHX53QhPKjl/MPc6JrB+oAW7eAu+P5J2PQFBHaE8X+Gs66xW2VL81V0AH78P1j+GjjL7T/T0ZOPmNp4RrhcsON7WPayvYGylx/0u9redqBDrwa5xZ68EqavSufjlenszS8lLNCXXw6O4ldnR9MlNKBB7tGUlFY4eWtpKi8v2ElJhZPrh8bwuwndad8QrfKl0azalcsrP6Tw/Zb9+Hl7cNXgaG4ZEU9MaPMfaVagE5Em71BpBR+tSOOdpbvYk19KfHgAt4yI5/KBkfh560Xvaaurg1dAOPx2tj1i56XA3OBK8uxOictfAcsThv8Ozr0XfAPdXZk0pMIsu3HKyjftDeAH/NpubhMc1bD3KSu098tb/goc2AFBneDsW2DQbyAgtGHvVcnpMvywLYsPlqczf+t+XMYetbtmSAwTe3XAx6t5j9oZY5i5bg9Tv0smM6+ECT0jePiCniRE6O9oc7Yjy+6M+cWaTJwuw4V9O3H7qK70jWrAzpiNTIFORJqsjIPFvL10Fx+vTKewzMGw+FBuGRnH2MSI027VL8D+TbDhE/vF5nFZENTRbpd/zFsXBb6T5ayw1zMt+Ks9Pa//tTDuMWjb2d2VyZl0aI8d4Fe/a283MegmGPl7++/W6chLgxWvwer/Qlk+RA6Cc+6CXpfam4I3kr35JXyyKoOPV6aTmVdCaIAPVw6O4pqzY4gNa36jdqt35/KXr7awNj2PXp3a8thFPTk3QU2JWpL9h0p5a2kqHyxLo6DMwfCEUG4f1ZWR3cKa3XpIBToRaXLWpufx+uIUvtu4Dwv4Rb9O3DKygfeVaa1yU2Hjp7DhM8jeYo8MeXqDo/TYawPCYeLT9gvGqrfdkJ9pjzTUFHiCwKc2+3bDk22z7Y3BD2y3N6ZOehY6neXuyqQx5aXDoudg7fvg4WWPog2/HwLD6/8cxkDaT3YTlq1fAZYd4M65y+0bzTtdhkXbs/lweRrztmbhdBmGJ4RyzZAYzuvVscmP2qUdKObv323l6w17iQjy5aGkRK4YGNWstqKRk3OotIIPKztj7j9URs9ObbljdDwX9e3UbPZhVKATkSbBWblw+Y3FKazcdZAgPy+uHRLDTcNj6RTs7+7ymreCffb6rA2fQmblv5kxw6DPFXYnvp3zT24NndMBBXuPCnqVYS8vDQ5lgstx5GMCO0JI9HECXwv/M963AWY/Cqk/QGiC3bky8QJtDN6a5abCD1Nh/Uf2Orcht9nTbtu0r/sxjjLY+Lnd6GTvOvALgcG/sUNhQ0/hbAD7D5Xyyap0PlxRY9RuUBRXnx1NfHjTmraYX1LBSwt28M7SXXh6WNw2Kp7bR8e3yI6IUrsyh5Mv1+7htUUp7MgqJDLEn1tGxnH12dHM2bS/STdaU6ATEbcqLnfw2eoM3lySyq4DxUSG+PPbEfY/oIG++o/0lJUchC2z7BC3a7G9cXDHvnbHvd6X2+Gqpobsculy1hL4dld/nJ9RS+DrUB3ygqOrw15IjF1rcw18h/bC/Gfs0Rj/ELuN/eDfNupUOGnicnbAD1Psv6s+gXDOndA2EhZPq/77OPwBKM6BlW9AURaEJdrX9bsafJp+Qweny7BkRw4fLk9j7pb9OF2GYfGhXDM0hqTeHdzaJbLC6eKD5Wn86/tt5JVUcMXAKB46L5GOwZpV0Fq5XIb5W7N4ddFOVu46iL+3BxVOg8NVnYWa2lZICnQi4hZZh0p596ddvL88jbziCvpHh3DryHjaUxkgAAAgAElEQVSSendoNlMcmpzyYtj2rf3CcPtccFXY+031/SX0ubLp7GVWFfjSjxP4Ko58TEBEHVM6KwNgU3tRW15kt65f+i97zdzQ2+1GGP7adFjqkLUFFv4NNn9Z9zXdzrODXPzYZju6m3WolE9WZ/DhijQyDpbQro03Vw6K4ldDYujaiKN2xhjmbcnir99uISW7iGHxoTx6UU9N7ZcjrN6dy3WvL6fU4TrmXGSIP0sfHueGqo6lQCcijWrrvkO8sTiVmWv3UOFykdSrI7eMjGNQl3bNbhFyk+Aot1uTb/gEtn4DFUV2d7s+V9hvnQc0vxd+Lqc9TTQvze6+WTPs5aXZQfCYwBdex3TOaHuEz6eRmjK4XPYUunlP26G116Uw4Uk7WIvUx7TuULj/2ONBHeH3yY1fzxniOjxqtyKNuZv343AZhsa159qhMST17nhGOxhv2pPPs19v4cedB4gPC+BPF/ZkfM8I/R8ktYp7+GtqS0EWkDrlosYup1b1DXT1mvdkWdb5wP8BnsAbxpgpR52/A7gbcAKFwG3GmM2V5x4Bbq48d58xZvbJfCEi0nQZY1i0PYc3FqeweHsO/t6eXDMkmt+OiGuRexadcS4X7F5qNzfZ/KU9vdK/HfSrHInrcm7z3sPMwxOCI+03hh173uWCwn1Hje5VjvbtXQ9bv7b3/aqpTVjtge/wlM6GCHypi+x1cvvW250Gr3wbutRSv8jxFGbVfryglpDXjHl4WIzqHs6o7uFkFZTy6eoMPlqRzu8+WktIG2+uGBjFNUOiSYgIarB77j9UyrTZyXz6cwYh/t48dUlvrh0a0yo2RZdT1znEn8y8klqPNzcnHKGzLMsT2AZMBDKAlcA1hwNb5TVtjTGHKj++BLjLGHO+ZVm9gA+BIUBn4HuguzFHt1E7kkboRJq2wwuM31ycSvL+AiKCfLnx3FiuGxpDSBttyHpSjIE9a2DjZ3ZThII94B0APS60Q1zXceCl7ylQGfj2HzudMz+9eoTPWXbkY9qE1hH2Kqd0Hr03XM01h0EdIKAD7FtnXzvhSXudoodeJMopqGtfyOBoeGBj49fTiFwuw487D/DhijRmb9qHw2UYEtuea4ZGc0GfTqc8aldc7uC1RSm8+kMKTpfhpuGx3D02gWB/rWWVE5uxJpNHPt9ASUV1LGmxa+gsyxoGPGmMSar8/BEAY8zf6rj+GuAGY8wFR19rWdbsyuf66Xj3VKATaZoOFpXz/vLdvPvTbrILyujRMYhbR8Zz8Vmdm3zL6iYne1vlNgOfQu5O8PCGbhOh75XQ/fzGm0rYkrhcdmOJ2tbvHR7pqy3wHW7WUlECKQuPnfbZ63K47OXm28BFmob100+u62wLlV1Qxmc/22vtdh8oJtjfm8sHRnLtkBi6dajfqJ3LZfjs5wymzUlm/6EyLurbiT+e34OY0Ca25laavBlrMltEl8v6TLmMBGr+SikDGFrLDe8GHgR8gMMrCSOBZUc9tul8l0SkXlJzinhzSQqfrs6gtMLF6O7h3HpVPMMTQrU24WTkZ9gjcRs+sdvdY0HcSBhxP/S8WI01TpeHh70eKagjRA859rzLBUXZtYS9NLtxxYHttT9v5kqFOTl9h0NbQ3WdbabCg3y5Y3RXbhsZz7KUA3ywIo33lu3m7aW7GNylHdcOjeHCvvaoXW0vtiOCfHnm6y1s3nuIs6JDeOnagQyOPc6WECLHMWlAZJMKcKeqPiN0vwSSjDG3VH7+a2CIMebeOq6/tvL6Gy3Legn4yRjzXuW5N4FvjDGf1fK424DbAGJiYgbt3r37NL4sETldxhhW7jrI64tT+H7Lfrw9PLhsQCQ3j4yjez1/iypAUQ5snmGPxKVVTk6IHFS5zcBldviQpuHJEKhrifyTeY1djUircaDw8KhdOqk5RbT18+Ks6BBWpOZSVqMLoYcFLmN3IfzD+Ylc3K8zHtoYXFqwhhyhywBqbmwUBew5zvUfAf852ccaY14DXgN7ymU96hKRM8DhdPHNxn28sTiF9Rn5tGvjzb1jE/j1sFjCg3zdXV7zUFZgN/DY8AnsXADGCeE9YNxjdodKdUZsmoKj6ljj1PQ2dhZpSUIDfbltVFduHRnPspRcPlyRxsx1x75cdBlo6+fFvN+PPqPdMkWam/oEupVAN8uy4oBM4FfAtTUvsCyrmzHm8FyVi4DDH88EPrAs63nspijdgBUNUbiINKyC0go+XpnO20t3kZlXQnxYAM9M6sMVA6Pw99F/nCdUUQo75tohbttscJRCcAwMv89ubtKhd/PbZqC1Gf947Wucxj/uvppEWhHLshjWNZRhXUOZtW5PrePlBaUOhTmRo5ww0BljHJZl3QPMxt624C1jzCbLsp4GVhljZgL3WJY1AagADgI3Vj52k2VZ04HNgAO4+0QdLkWkcWXmlfDO0lQ+WpFOQZmDoXHteeqS3ozrEaGpLCfidEDqD/a6uC2zoOyQvW/awBvsEBc9RCGuOdEaJ5EmoyW1lBc507SxuEgrtT4jj9cXp/LNhr0AXNS3E7eMjKNfVIibK2vijIH0FXaHyk1f2E02fNvaTU36XAFxo8GzXlt8iohIHZpDS3mRM61BNxYXkZbB5TLM25rF64tTWJGaS5CvFzePiOPGc2OJ1G8962YM7N9kh7iNn9ldEb38oHuS3dwkYSJ4+7m7ShGRFuNwaGvKLeVFmgoFOpFWoKTcyac/Z/DWklRSc4qIDPHnsYt6cvXZ0QT5aQPWOuWmVu8Vl70VLE/oOhbGPgqJF4JfW3dXKCLSYrWUlvIiZ5oCnUgLllVQyv9+2s17y3ZzsLiCs6KC+fc1A7igT0e8PLUReK0K9tlTKTd8Apmr7WMx58JF/4BekyAgzL31iYiIiNSgQCfSAiXvK+DNJSnMWLOHCpeLiT07cOuoeAZ3aaeNwGtTchA2z7RH43YtAeOCjv1g4tPQ+3IIiT7xc4iIiIi4gQKdSAthjGHJjhxeX5zKom3Z+Hl7cPXZ0fx2RBxxYQHuLq/pKS+C5G/tNXHb54KrAtp3hVGT7Q6V4d3dXaGIiIjICSnQiTRzZQ4ns9bt5Y3FKWzdV0B4kC+TkxK5dkgM7QJ83F1e0+Ioh53z7ZG4rd9ARREEdYKht0PfK6FTf20zICIiIs2KAp1IM5VXXM77y9N498ddZBWU0aNjEM9d2Y9L+nfG10ubrlZxuWD3UjvEbf7Snl7p3w76/dIeietyLnjo+yUiIiLNkwKdSDOzK6eIt5am8smqDEoqnIzsFsa0X57FyG5hWh93mDGwZ409nXLjZ1CwF7wDoMeFdojrOg68NHopIiIizZ8CnUgzYIxh1e6DvLE4hTmb9+Pt4cGl/Ttzy8h4EjsGubu8piM72d5iYOOnkJsCHt7QbSL0fRa6nw8+WksoIiIiLYsCnUgT5nC6+G7TPl5fnMq69DxC2nhz95gEbji3CxFBrXQj6/XTYd7TkJ8BwVEw7G5wlNkhbt8GwIK4kTDiAeh5sT29UkRERKSFUqATcbMZazJ5bnYye/JK6Bziz+SkRCb06sDHK9N5a0kqmXklxIUF8JdJfbhyYBT+Pq14vde6j2DW/eAosT/PT4fvHrY/jhwM50+B3pdBUEf31SgiIiLSiBToRNxoxppMHvl8AyUVTgAy80p46JN1eFpQ5jQMiW3PExf3YkLPDnh4tID1cU4HlB2C0jwoza/xduioz+t4Ky+o/XmDOsGt8xr3axERERFpAhToRNzoudnJVWHuMIfL4O3twZd3nMtZ0SFuqqwOzorK8HVUICurbyArPMENLPALPvKtfRz4hdgfL3up9ocV7GvwL1VERESkOVCgE2kExhgOFJWzfX8hO7IL2bG/gB3ZhWTmlXCJxxL+4DWdzlYOe0wYUx1XMatixJkJc47yGuEr7+RHyCqKjv/8lsexgSy0K/gGH3u8tjefQPDwqPv5t8y0p1keLTjq9L4vIiIiIs2UAp1IAzLGsDe/lO1ZhezIKmRHVgE7sgrZnlVIXnFF1XUBPp4kRARypc+PPG29QRurHIAoK4cp3m/Q3tsHuOjYGzjKjwpZeSc3SlZRfPwvwPKsDFdtq0NWWELlxyH1C2RncuuE8Y/DrPugoqT6mLe/fVxERESkFVKgEzkFTpchLbe4MqwVVIa3QnZmFVJUXj2Fsl0bb7pFBHFBn050iwgkISKQbh0C6djWD8uyKP77LbQpKT/iudtY5TxmXoX3Nh0byBwlR5dypKpAVuMtrEONz08QynwCzmwgO139rrLf1+xyOf7x6uMiIiIirYwCnchxlDmc7Mo5Nril5BRR7nBVXdexrR8JEYH8cnA0CYeDW0QgoYG+dTxxAWybTZuSvbWe9nKWQHGOHbLadjoqeNURynzbNv1A1hD6XaUAJyIiIlJJgU4EKC53sDOrqCq0ba8cbdudW4zTZQA7J0W3a0NCRCCju4fTtTK0dY0IpK2f94lvUl4E276DTV/A9rngKLXXnBnXsdcGR8NtCxv0axQRERGRlkeBTlqVvOLyqlG26nVudnOSw7w8LGLDAkjsGMRF/TpVjbh1DQ/Ez/sk94ArL4btc+wQt222PWUysAMMvAF6Xw55afDV77QmTEREREROiQKdtDjGGLILyuywll1od5asDHA5hWVV1/l6edA1PJDBse34VXg03TrYwa1LaADensfptHgiFSX2CNymL+wRuYpiCAiHAdfZm17HDAOPymDYZZg99Kc1YSIiIiJyChTopNlyuQyZeSWV2wAUHrHO7VCpo+q6IF8vEjoEMjYxvCq0dYsIIjLEv+E2664ohR3fV4e48kJoEwZn/coOcV2GV4e4o2lNmIiIiIicIgU6afIcThe7c4vZvr+QndmFbK/cw21nVtERm3KHBviQEBHIxWd1ruwoGUS3DoFEBPlinYlGIY4y2DnfDnFbv4HyAvBvD32vrAxxI8BTf8VERERE5MzRq01pMkornKTmFB2zh1tqThEVTlN1XedgP7pGBHLNkNCqbQASwgNpF+Bz5ot0lEPKgsoQ97W995tfCPSeZIe4uFHgWY8GKSIiIiIiDUCBThrcjDWZPDc7mT15JXQO8WdyUiKTBkRWnS8sc9RoTFLAzsr1bem5xVQ2lMTDgpj2dkfJcT06VG0D0DUikEDfRv6xdZRD6g+VIe4rez84v2DoeYkd4uJHK8SJiIiIiFtYxpgTX9XIBg8ebFatWuXuMuQUzFiTySOfbzhiKqS3p8Ww+FAMsCOrkL35pUeciwsLoFtEUNU2AAkRgcSFBZx8R8mG5KyoDnFbvoLSPPANhh4XVYa4MeDVCCOCIiIiItIqWZa12hgz+ETXaYROGtRzs5OPCHMAFU7D4u059IkM5pz40KptABIiAunSvg1ep9NRsiE5HbBrcWWImwUlueATBD0utENc13HgVcdG4SIiIiIibqBAJw1qT4393I42694RjVhJPbmcsGtJZYibCcUHwCcQEi+oDHHjwdvP3VWKiIiIiNRKgU4aVIdgP/bVmFJ5WOcQfzdUUweXE9J+go2f2yGuKBu8AyDxfDvEJUywN/cWEREREWniFOikQSVGBB4T6Py9PZmclOimiiq5XJC+zB6J2/wlFO4H7zbQPakyxE0EnzburVFERERE5CQp0EmDycwr4aeUXIbGtSPjYGmdXS4bjcsFGSuqQ1zBXvDyg27n2SGuexL4BDR+XSIiIiIiDUSBThrMv+ZuA+D5qwcQ6a4plsZAxirY9DlsmgEFe8DTF7pNrAxx54NvoHtqExERERFpYAp00iB2ZBXw2c8Z/GZ4XOOHOWMg82c7xG3+EvLTwdPHXgvX+2l7JM6vbePWJCIiIiLSCBTopEH8Y842/L09uWtM18a5oTGwZ409nXLTDMhPAw9vSBgP4x6zu1T6BTdOLSIiIiIibqJAJ6dtfUYe327cx+/GdyM08Azu02YM7FtfGeK+gIO7wMPL3h9u7COQeCH4h5y5+4uIiIiINDEKdHLanpudTLs23twyMq7hn9wY2L+xOsTlpoDlCfFjYNRkO8S1ad/w9xURERERaQYU6OS0/Lgjh8Xbc3jsop4E+Xk3zJMaA1mbq0PcgR12iIsbBcPvh54XK8SJiIiIiKBAJ6fBGMPfZyfTKdiP68/pcvpPmLWlOsTlbAPLA2JHwrB77BAXEHb69xARERERaUEU6OSUzdm8n3Xpefz9ir74eXue2pNkb6sOcdlbAAtiR8DQO6DnJRAY3qA1i4iIiIi0JAp0ckqcLsO02cnEhwdwxcCok3twzo7qEJe1CbCgy7lw4TQ7xAV1OCM1i4iIiIi0NPUKdJZlnQ/8H+AJvGGMmXLU+QeBWwAHkA381hizu/KcE9hQeWmaMeaSBqpd3GjGmky2ZxXy0rUD8fL0OPLk+ukw72nIz4DgKBj/OEQOqt5iYH/lj0PMMLhgqh3i2nZq/C9CRERERKSZO2GgsyzLE3gJmAhkACsty5ppjNlc47I1wGBjTLFlWXcCU4GrK8+VGGP6N3Dd4kZlDifPz91Gn8i2XNCn45En10+HWfdBRYn9eX46fH4bYOzPo4fC+VPsEBcc2ah1i4iIiIi0NPUZoRsC7DDGpABYlvURcClQFeiMMQtqXL8MuL4hi5Sm5cPlaWTmlfDXy/vi4WEdeXLe09VhrooBvxC4c6k9YiciIiIiIg3C48SXEAmk1/g8o/JYXW4Gvq3xuZ9lWassy1pmWdakuh5kWdZtldetys7OrkdZ4g5FZQ5eXLCDc+LbM6pbLV0n8zNqf2BpvsKciIiIiEgDq88InVXLMVPrhZZ1PTAYGF3jcIwxZo9lWfHAfMuyNhhjdh7zhMa8BrwGMHjw4FqfX9zv7aWp5BSW89oNPbCsWn40AsKgqJZArjAnIiIiItLg6jNClwFE1/g8Cthz9EWWZU0AHgUuMcaUHT5ujNlT+T4FWAgMOI16xY0OFpXz6g8pTOjZgYEx7Y69oPQQuJwc8zsAb3+7MYqIiIiIiDSo+gS6lUA3y7LiLMvyAX4FzKx5gWVZA4BXscNcVo3j7SzL8q38OAwYTo21d9K8vPLDTgrLHUxOSqz9gjmPQmkejH4YgqMBy35/8QvQ76pGrVVEREREpDU44ZRLY4zDsqx7gNnY2xa8ZYzZZFnW08AqY8xM4DkgEPikchre4e0JegKvWpblwg6PU47qjinNxL78Ut75cReT+keS2DHo2Au2fw8//xeG3w9jH7bfRERERETkjKrXPnTGmG+Ab4469niNjyfU8bgfgb6nU6A0DS/M347LGB6Y0P3YkyV5MPNeCO8BYx5p/OJERERERFqpegU6ad125RQxfWU61w6NISa0zbEXfPcwFO6Haz4Ab7/GL1BEREREpJWqzxo6aeWen7sNb08P7hmXcOzJrd/Aug9h5O+hs/rdiIiIiIg0JgU6Oa5Ne/KZuW4PvxkeS0TQUaNvxbkw63fQoS+MmuyeAkVEREREWjFNuZTjmjY7mbZ+Xtw+quuxJ795CEoOwq8/By+fxi9ORERERKSV0wid1GnlrlwWJGdz55gEgtt4H3ly0wzY+BmM/iN0VN8bERERERF3UKCTWhljmPrdViKCfLnp3NgjTxZmw9cPQqf+MOIBt9QnIiIiIiIKdFKHhcnZrNx1kHvHd8Pfx7P6hDHw9QNQVgCXvQKemrUrIiIiIuIuCnRyDJfLMHV2MjHt23D14OgjT274FLbMgrGPQkRP9xQoIiIiIiKAAp3UYtb6PWzZe4gHJ3bHx6vGj0jBPrsRStTZcO697itQREREREQABTo5SoXTxfNzt9GjYxCXnNW5+oQx9hYFjlKY9B/w8Kz7SUREREREpFEo0MkRpq9KZ/eBYiYnJeLhYVWfWPsBbPsOxj8BYd3cV6CIiIiIiFRRoJMqpRVOXpi3nUFd2jGuR0T1ifxM+O5hiDkXht7hvgJFREREROQICnRS5d0fd7H/UBl/SErEsipH54yBmfeAywGTXgIP/ciIiIiIiDQV6jkvAOSXVPDywp2M7h7O0PjQ6hOr34Gd8+HCadA+3m31iYiIiIjIsTTcIgC8viiF/JIKJiclVh88uBvmPAZxo2Hwze4rTkREREREaqVAJ2QXlPHW0lR+0a8TfSKD7YMuF3x5N2DBpS9qqqWIiIiISBOkKZfCSwt2UOZw8fvzaozOrXwDdi2Gi1+AkBj3FSciIiIiInXSsEsrl55bzPvLd3PV4CjiwgLsgwd2wvdPQMIEGHiDewsUEREREZE6KdC1cv/8fhuWZXHf+Mq95VxOe6qlh7c9OmdZx38CERERERFxGwW6Vmzb/gK+WJPJjcO60CnY3z647D+Q9hNc8HcIjnRvgSIiIiIiclwKdK3YtNnJBPp4cdeYBPtA9jaY/xdIvBDO+pV7ixMRERERkRNSoGul1qQdZM7m/dw6Kp52AT7gdMCMO8HbH37xL021FBERERFpBtTlshUyxjD1u2RCA3z47Yg4++CPL0DmKrjiTQjq4N4CRURERESkXjRC1wot2ZHDTykHuHtsAoG+XrB/Myz8G/S6FPpc4e7yRERERESknhToWhljDM/NTiYyxJ/rzokBZwXMuAN828JFz2uqpYiIiIhIM6JA18p8t3Ef6zPyuX9CN3y9PGHx87B3HfzinxAQ5u7yRERERETkJCjQtSIOp4tpc5JJiAjk8oFRdpBbNBX6/hJ6XeLu8kRERERE5CQp0LUin6/JZGd2EQ+d1x1PVwV8cSe0CYULprq7NBEREREROQXqctlKlFY4+dfcbZwVFUxS744w/xnI2gTXfAxt2ru7PBEREREROQUaoWsl3l+exp78UiYn9cDa8zMs+Sf0vw4Sz3d3aSIiIiIicooU6FqBwjIHLy3YwfCEUEbEBtpTLYM6QtJf3V2aiIiIiIicBk25bAXeXJxKblE5k5N6wIJnIScZrv8M/EPcXZqIiIiIiJwGjdC1cLlF5by+OIWk3h3ob5Lhx3/DoJsgYYK7SxMRERERkdOkEboW7uUFOygudzB5bAx8fj4ER8N5z7i7LBERERERaQAKdC3YnrwS/rtsN5cNiCJhw/OQuxNunAW+Qe4uTUREREREGoCmXLZgL8zbDgb+2CMblv8HhtwGcaPcXZaIiIiIiDQQjdC1UCnZhXyyOoObzw4nYv7N0C4OJjzp7rJERERERKQBKdC1UP+Yuw1fLw8e4D3IS4PffAs+Ae4uS0REREREGlC9plxalnW+ZVnJlmXtsCzr4VrOP2hZ1mbLstZbljXPsqwuNc7daFnW9sq3GxuyeKndxsx8vl6/l6f6ZOO/7h0Ydjd0GebuskREREREpIGdMNBZluUJvARcAPQCrrEsq9dRl60BBhtj+gGfAlMrH9seeAIYCgwBnrAsq13DlS+1mTo7mSj/cq7I+BuEdoNxj7m7JBEREREROQPqM0I3BNhhjEkxxpQDHwGX1rzAGLPAGFNc+ekyIKry4yRgrjEm1xhzEJgLnN8wpUttlqUcYNG2bF7vOAOPgr1w2Svg7e/uskRERERE5AyoT6CLBNJrfJ5ReawuNwPfnuxjLcu6zbKsVZZlrcrOzq5HWXI0YwxTv9vKZYEb6bl3Bgz/HUQNdndZIiIiIiJyhtQn0Fm1HDO1XmhZ1wODgedO9rHGmNeMMYONMYPDw8PrUZYcbd6WLHakZfCs5xsQ3hPGPOLukkRERERE5AyqT6DLAKJrfB4F7Dn6IsuyJgCPApcYY8pO5rFy+pwuw3Ozk3ku8AP8yw/AZf8BL193lyUiIiIiImdQfQLdSqCbZVlxlmX5AL8CZta8wLKsAcCr2GEuq8ap2cB5lmW1q2yGcl7lMWlgM9dlEpO9gCTHQqxRD0HnAe4uSUREREREzrAT7kNnjHFYlnUPdhDzBN4yxmyyLOtpYJUxZib2FMtA4BPLsgDSjDGXGGNyLcv6C3YoBHjaGJN7Rr6SVqzc4eLNOav4n+9bmA59sUY+5O6SRERERESkEdRrY3FjzDfAN0cde7zGxxOO89i3gLdOtUA5sY9XpnF74X8I9i7CmvQKePm4uyQREREREWkE9dpYXJqu4nIHm77/Lxd7LsMa/Ufo2MfdJYmIiIiISCNRoGvmPlqwmj84XqUotB/WiAfcXY6IiIiIiDSiek25lKYpv6icLj89SpBVhvfVr4On/jhFRERERFoTjdA1Y4u+eJnxrCR36B8gooe7yxERERERkUamQNdM5ezZxajtU0nx70OHpN+7uxwREREREXEDBbrmyBgOfHQHPlTge8V/wMPT3RWJiIiIiIgbKNA1QzlL3iLx0E/Mi7yDyIR+7i5HRERERETcRIGuucnPIGDBn1lhenL21Y+4uxoREREREXEjBbrmxBiKPrkDl9PB6v7P0CG4jbsrEhERERERN1Kga05Wv01AxmKet37NNUmj3F2NiIiIiIi4mQJdc3FwF87vHmWxsw/tR91BSBsfd1ckIiIiIiJupp2omwOXCzPjLsqcMMXnHj4ZEefuikREREREpAnQCF1zsPJ1rN1LebL8Oq4aP4w2PsrhIiIiIiKiQNf0HdiJmfsEK70H82PQBVwzJMbdFYmIiIiISBOhQNeUuZww404qLG/uKbiJByYm4uOlPzIREREREbEpHTRlP70E6cv5h8dvCe4Qw6QBke6uSEREREREmhAFuqYqOxnmP0NGh7G8mn82D52XiKeH5e6qRERERESkCVGga4qcDvjiDoxPALfl/poBMe2Y2KuDu6sSEREREZEmRoGuKVr6L9jzM/Pj/8DmAj8mJyViWRqdExERERGRI6n/fVOzfxMsnEJFj0t5aEtXRnYL5tyuYe6uSkREREREmiCN0DUlzgr44g7wD+H1tvdwsLiCyUmJ7q5KRERERESaKAW6pmTRNNi3nkMTpvLSslwu7NuRflEh7q5KRERERESaKAW6pmLPWlg8DfpexT8zEimpcPLgRI3OiYiIiIhI3RTomgJHGWKGCTAAABY4SURBVMy4E9qEkXnuk7y/LI0rB0WREBHo7spERERERKQJU1OUpmDhFMjaDNdO519LcgD43YTubi5KRERERESaOo3QuVvGanubgv7XsyPkXD77OYNfD+tCZIi/uysTEREREZEmToHOnSpKYMYdENQJzv8r/5izDX9vT+4a09XdlYmIiIiISDOgQOdO85+BnG1wyb9Zl234duM+bhkZT2igr7srExERERGRZkCBzl12/wQ/vQSDfgMJ43ludjLt2nhzy8g4d1cmIiIiIiLNhAKdO5QXwZd3QUg0nPcXftyRw5IdOdw9NoEgP293VyciIiIiIs2Euly6w/dPQW4K3PgVxieQv89eT6dgP64/p4u7KxMRERERkWZEI3SNLXURrHgVhtwOcSOZs3k/69LzuH9CN/y8Pd1dnYiIiIiINCMKdI2prAC+vBvax8OEJ3C6DNNmJxMfHsAVA6PcXZ2IiIiIiDQzCnSNac6fIS8dJv0HfAL4Yk0m27MK+f3ERLw89UchIiIiIiInRymiseyYB6vfhmF3Q8w5lDmc/HPuNvpEtuWCPh3dXZ2IiIiIiDRDCnSNoTQfZt4LYd1h3GMAfLg8jcy8EiYn9cDDw3JzgSIiIiIi0hypy2Vj+O5PULAXbv4evP0pKnPw4oIdnBPfnlHdwtxdnYiIiIiINFMaoTvTkr+Dte/B8PshahAAby1JJaewnD+c3wPL0uiciIiIiIicGgW6M6k4F2b9DiJ6w5iHAThYVM5ri1KY0LMDA2PaublAERERERFpzuoV6CzLOt+yrGTLsnZYlvVwLedHWZb1s2VZDsuyrjzqnNOyrLWVbzMbqvBm4ds/QnEOTHoZvHwBeOWHnRSWO5iclOjm4kREREREpLk74Ro6y7I8gZeAiUAGsNKyrJnGmM01LksDbgIequUpSowx/Rug1uZlyyzYMB1GPwyd7S9/X34p7/y4i0n9I0nsGOTmAkVEREREpLmrT1OUIcAOY0wKgGVZHwGXAlWBzhizq/Kc6wzU2PwU5cCs+6FjPxhVnXFfmL8dlzE8MKG7G4sTEREREZGWoj5TLiOB9BqfZ1Qeqy8/y7JWWZa1zLKsSXVdZFnWbZXXrcrOzj6Jp2+Cvv69vVXBZa+ApzcAqTlFfLwynWuGxBAT2sbNBYqIiIiISEtQn0BXWxtGcxL3iDHGDAauBf5lWVbX2i4yxrxmjBlsjBkcHh5+Ek/fxGz8DDbPsJugdOhddfj5udvw8fTgnnEJbixORERERERakvoEugwgusbnUcCe+t7AGLOn8n0KsBAYcBL1NS8F++3RuchB9jYFlTbtyWfWuj38ZngsEUF+bixQRERERERakvoEupVAN8uy4izL8gF+BdSrW6VlWe0sy/Kt/DgMGE6NtXctijHw1QNQXgyT/gOe1csTp81Opq2fF7ePqnVwUkRERERE5JScMNAZYxzAPcBsYAsw3RizybKspy3LugTAsqyzLcvKAH4JvGpZ1qbKh/cEVlmWtQ5YAEw5qjtmy7H+Y0j+GsY9BuHVWxKsSM1lQXI2d45JILiNtxsLFBERERGRlqY+XS4xxnwDfHPUscdrfLwSeyrm0Y/7Eeh7mjU2fYf2wDd/gOhzYNjdVYeNMUz9bisRQb7cdG6s++oTEREREZEWqV4bi8txGAMz7wNnub2BuIdn1akFyVms2n2Qe8d3w9/H8zhPIiIiIiIicvLqNUInx7Hmf7BjLpz/dwitXiPnchmem72NmPZtuHpw9HGeQERERERE5NRohO505KXBd3+C2JEw5LYjTs1av4ctew/x4MTu+Hjp2ywiIiIiIg1PSeNUGQNf3gPGBZe+CB7V38oKp4vn526jR8cgLjmrsxuLFBERERGRlkyB7lStehNSf4Dz/gLtYo84NX1VOrsPFDM5KREPj9r2ZRcRERERETl9CnSnIjcV5jwO8WNh8G+POFVS7uT/vt/OoC7tGNcjwk0FioiIiIhIa6BAd7JcLvjybrub5aUvgnXkCNy7P+0iq6CMPyQlYlkanRMRERERkTNHXS5P1opXYfdSuPQlCD5y6738kgr+s3Ano7uHMzQ+1E0FioiIiIhIa6ERupORswO+fwq6nQf9rzvm9OuLUsgvqWByUqIbihMRERERkdZGI3T1sX46zHsK8jMACxImHjPVMrugjDeXpPKLfp3oExnsnjpFRERERKRVUaA7kfXTYdZ9UFFSecDA94+Dfwj0u6rqshfnb6fc6eL352l0TkREREREGoemXJ7IvKdrhLlKFSX28UrpucV8sCKNqwZHERcW0MgFioiIiIhIa6VAdyL5GSc8/s/vt2FZFveN79ZIRYmIiIiIiCjQndhRnSyPPr5tfwFfrMnkxmFd6BTs34iFiYiIiIhIa6c1dCcy/vGj1tAB3v72cWDa7GQCfby4a0yCmwoUkdamoqKCjIwMSktL3V2KyCnx8/MjKioKb29vd5ciItLsKdCdyOHGJ/OetqdZBkfZYa7fVfycdpA5m/fz4MTutAvwcW+dItJqZGRkEBQURGxsLNZRHXdFmjpjDAcOHCAjI4O4uDh3lyMi0uwp0NVHv6uO6GgJ9n9Iz32XTGiAD78dof+QRKTxlJaWKsxJs2VZFqGhoWRnZ7u7FBGRFkFr6E7Rkh05/JRygLvHJhDoq1wsIo1LYU6aM/38iog0HAW6U2CM4bnZyUSG+HPdOTHuLkdERERERFopBbpT8N3GfazPyOf+Cd3w9fJ0dzkiIsc1Y00mw6fMJ+7hrxk+ZT4z1mS6u6TWbf10+GcfeDLEfr9++mk/5a5du+jTp08DFHeshQsX8otf/AKAmTNnMmXKlDNyHxEROTUKdCfJ4XTx3JxkEiICuXxgHVsaiIg0ETPWZPLI5xvIzCvBAJl5JTzy+YYzGuouvPBC8vLyyMvL4+WXX646XjMYtFrrp9udk/PTAWO/n3Vfg4S6xnDJJZfw8MMPu7sMERGpQYu/TtLnP2eSkl3EK9cPxNNDawBExL2emrWJzXsO1Xl+TVoe5U7XEcdKKpz84dP1fLgirdbH9Orclicu7n3KNX3zzTeAPWr08ssvc9ddd53yc50qh8OBl5cb/ov79mHYt6Hu8xkrwVl25LGKEvjyHlj9bu2P6dgXLjjxqJjD4eDGG29kzZo1dO/enf/+979MmzaNWbNmUVJSwrnnnsurr76KZVm88MILvPLKK3h5edGrVy8++ugjioqKuPfee9mwYQMOh4Mnn3ySSy+99Ih7vPPOO6xatYoXX3yRm266ibZt27Jq1Sr27dvH1KlTufLKKwF47rnnmD59OmVlZVx22WU89dRTJ6xfREROjUboTkJphZN/fb+Ns6KCSerd0d3liIic0NFh7kTH62Pq1Km88MILADzwwAOMGzcOgHnz5nH99dcTGxtLTk4ODz/8MDt37qR///5MnjwZgMLCQq688kp69OjBddddhzGmzvvExsbyxBNPMHDgQPr27cvWrVsByM3NZdKkSfTr149zzjmH9evXA/Dkk09y2223cd5553HDDTfwzjvvMGnSJC6++GLi4uJ48cUXef755xkwYADnnHMOubm5p/w9OGVHh7kTHT8JycnJ3Hbbbaxfv562bdvy8ssvc88997By5Uo2btxISUkJX331FQBTpkxhzZo1rF+/nldeeQWAZ599lnHjxrFy5UoWLFjA5MmTKSoqOu499+7dy5IlS/jqq6+qRu7mzJnD9u3bWbFiBWvXrmX16tUsWrTotL8+ERGpnUboTsL7y9PYk1/K1CvPUocuEWkSTjSSNnzKfDLzSo45Hhniz8e3Dzule44aNYp//OMf3HfffaxatYqysjIqKipYsmQJI0eOZMmSJYAdGjZu3MjatWsBe8rlmjVr2LRpE507d2b48OEsXbqUESNG1HmvsLAwfv75Z15++WWmTZvGG2+8wRNPPMGAAQOYMWMG8+fP54Ybbqi6x+rVq1myZAn+/v688847bNy4kTVr1lBaWkpCQgJ///vfWbNmDQ888AD//e9/uf/++0/pe1CnE42k/bNP5XTLowRHw2++Pq1bR0dHM3z4cACuv/56XnjhBeLi4pg6dSrFxcXk5ubSu3dvLr74Yvr168d1113HpEmTmDRpEmAHsZkzZzJt2jTA3h4jLa32UdzDJk2ahIeHB7169WL//v1VzzNnzhwGDBgA2CF++/btjBo16rS+PhERqZ1G6OphxppMhv1tHn/5ajO+Xh7kFJ7+b1JFRBrD5KRE/L2PbN7k7+3J5KTEU37OQYMGsXr1agoKCvD19WXYsGGsWrWKxYsXM3LkyOM+dsiQIURFReHh4UH//v3ZtWvXca+//PLLq+55+NolS5bw61//GoBx48Zx4MAB8vPzAXuNl7+/f9Xjx44dS1BQEOHh4QQHB3PxxRcD0Ldv3xPe+4wY/zh4+x95zNvfPn6ajv5Fo2VZ3HXXXXz66ads2LCBW2+9ldLSUgC+/vpr7r77blavXs2gQYNwOBwYY/jss89Yu3Yta9euJS0tjZ49ex73nr6+vlUfHx5tNcbwyCOPVD3Pjh07uPnmm0/76xMRkdop0J3A4YYCe/Pt/wTLHK4z3lBARKShTBoQyd8u70tkiD8W9sjc3y7vy6QBkaf8nN7e3sTGxvL2229z7rnnMnLkSBYsWMDOnTtPKgB4enricDjqdX3Na2ubpnk4zAQEBNR5Pw8Pj6rPPTw8TnjvM6LfVXDxC/aIHJb9/uIX7OOnKS0tjZ9++gmADz/8sGrkMywsjMLCQj799FMAXC4X6enpjB07lqlTp5KXl0dhYSFJSUn8+9//rvr+rlmz5pTqSEpK4q233qKwsBCAzMxMsrKyTvfLExGROmjK5Qk8NzuZkgrnEcdKKpw8Nzv5tF4QiYg0lkkDIhv836tRo0Yxbdo03nrrLfr27cuDDz7IoEGDjhglCgoKoqCgoEHve/je77//Pn/+859ZuHAhYWFhtG3btsHvc8b0u6pBAtzRevbsybvvvsvtt99Ot27duPPOOzl48CB9+/YlNjaWs88+GwCn08n1119Pfn4+xhgeeOABQkJC+POf/8z9999Pv379MMYQGxtbtebuZJx33nls2bKFYcPsKb2BgYG89957RERENOjXKyIiNgW6E9hTy9qT4x0XEWkNRo4cybPPPsuwYcMICAjAz8/vmOmWoaGhDB8+nD59+nDBBRdw0UUXNci9n3zySX7zm9/Qr18/2rRpw7vv1tEdshWJjY1l8+bNxxx/5plneOaZZ445fnidY03+/v7/397dhlha1nEc//7Y3ZpVEastUcfcjRbLIlMGMYUYNFijyJYIlQpXfCWVU4S19aY3vWgpwkQJzSwjMcJckggf2KLoAWt9qNw2SXZNJ9ccN8wK8al/L869MNq6465z9pr73u8HDue+rznc/A5cnDn/+3o4XH311f/XPj09zfT0NAAbNmxgw4YNwGjHy/n2jMgBzMzMMDMzsx/vQJJ0oLKvHcZamZqaqq1bt7aOAex7Q4FfbTyrQSJJh7rt27cvOLVRWursx5K0b0nuqqqphV7nGroFjGNDAUmSJElaDE65XMCedSdfue1+HnniKY49aiWXrTvR9XOStEjWr1/Pzp07X9C2adMm1q1b1yiRJEn9YUH3MoxjQwFJeiWqajC/h7l58+bWEXSQLcXlHpLUV065lKSemZiYYPfu3X4pVi9VFbt372ZiYqJ1FEkaBEfoJKlnJicnmZ2dZW5urnUU6YBMTEwwOTnZOoYkDYIFnST1zIoVK1izZk3rGJIkaQlwyqUkSZIk9ZQFnSRJkiT1lAWdJEmSJPVUluIuaUnmgL+2zrEXq4DHW4fQYNm/NE72L42T/UvjZP/SuC3VPnZCVb1+oRctyYJuqUqytaqmWufQMNm/NE72L42T/UvjZP/SuPW9jznlUpIkSZJ6yoJOkiRJknrKgm7/XNM6gAbN/qVxsn9pnOxfGif7l8at133MNXSSJEmS1FOO0EmSJElST1nQSZIkSVJPWdC9DEnOSXJ/kgeSbGydR8OR5PgkP0uyPcm2JDOtM2l4kixLck+SH7fOouFJclSSm5L8ufsse1frTBqOJJ/u/j/el+TGJBOtM6m/klyX5LEk981re22SO5L8pXt+TcuMB8KCbgFJlgFXAe8FTgIuSHJS21QakOeAz1TVW4HTgY/bvzQGM8D21iE0WF8Hbq2qtwAnY1/TIklyHHApMFVVbweWAee3TaWe+w5wzovaNgJbqmotsKU77xULuoWdBjxQVTuq6hng+8C5jTNpIKpqV1Xd3R3/i9EXoePaptKQJJkE3gdc2zqLhifJkcC7gW8BVNUzVfVE21QamOXAyiTLgcOARxrnUY9V1S+Af7yo+Vzg+u74euCDBzXUIrCgW9hxwMPzzmfxC7fGIMlq4BTgzrZJNDCXA58F/ts6iAbpTcAc8O1uWu+1SQ5vHUrDUFV/A74KPATsAv5ZVbe3TaUBOrqqdsHoRjvwhsZ59psF3cKylzZ/60GLKskRwA+BT1XVk63zaBiSvB94rKruap1Fg7UcOBX4RlWdAvyHHk5X0tLUrWU6F1gDHAscnuSjbVNJS48F3cJmgePnnU/icL8WUZIVjIq5G6rq5tZ5NChnAh9I8iCj6eJnJfle20gamFlgtqr2zCy4iVGBJy2G9wA7q2quqp4FbgbOaJxJw/P3JMcAdM+PNc6z3yzoFvY7YG2SNUlexWgx7i2NM2kgkoTR2pPtVfW11nk0LFX1+aqarKrVjD67flpV3t3WoqmqR4GHk5zYNZ0N/KlhJA3LQ8DpSQ7r/l+ejZvuaPHdAlzYHV8I/KhhlgOyvHWApa6qnkvyCeA2RrsrXVdV2xrH0nCcCXwM+GOSe7u2L1TVTxpmkqT98Unghu6m5w7gosZ5NBBVdWeSm4C7Ge0KfQ9wTdtU6rMkNwLTwKoks8AXgS8DP0hyMaObCB9ul/DApMrlYJIkSZLUR065lCRJkqSesqCTJEmSpJ6yoJMkSZKknrKgkyRJkqSesqCTJEmSpJ6yoJMkDVaS55PcO++xcRGvvTrJfYt1PUmSDoS/QydJGrKnquqdrUNIkjQujtBJkg45SR5MsinJb7vHm7v2E5JsSfKH7vmNXfvRSTYn+X33OKO71LIk30yyLcntSVY2e1OSpEOSBZ0kachWvmjK5Xnz/vZkVZ0GXAlc3rVdCXy3qt4B3ABc0bVfAfy8qk4GTgW2de1rgauq6m3AE8CHxvx+JEl6gVRV6wySJI1Fkn9X1RF7aX8QOKuqdiRZATxaVa9L8jhwTFU927XvqqpVSeaAyap6et41VgN3VNXa7vxzwIqq+tL435kkSSOO0EmSDlX1Escv9Zq9eXre8fO4Nl2SdJBZ0EmSDlXnzXv+TXf8a+D87vgjwC+74y3AJQBJliU58mCFlCRpX7yTKEkaspVJ7p13fmtV7fnpglcnuZPRzc0LurZLgeuSXAbMARd17TPANUkuZjQSdwmwa+zpJUlagGvoJEmHnG4N3VRVPd46iyRJr4RTLiVJkiSppxyhkyRJkqSecoROkiRJknrKgk6SJEmSesqCTpIkSZJ6yoJOkiRJknrKgk6SJEmSeup/J2zi2XsbRBQAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff64571deb8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "def plot_training_history(title, label, baseline, bn_solvers, plot_fn, bl_marker='.', bn_marker='.', labels=None):\n",
    "    \"\"\"utility function for plotting training history\"\"\"\n",
    "    plt.title(title)\n",
    "    plt.xlabel(label)\n",
    "    bn_plots = [plot_fn(bn_solver) for bn_solver in bn_solvers]\n",
    "    bl_plot = plot_fn(baseline)\n",
    "    num_bn = len(bn_plots)\n",
    "    for i in range(num_bn):\n",
    "        label='with_norm'\n",
    "        if labels is not None:\n",
    "            label += str(labels[i])\n",
    "        plt.plot(bn_plots[i], bn_marker, label=label)\n",
    "    label='baseline'\n",
    "    if labels is not None:\n",
    "        label += str(labels[0])\n",
    "    plt.plot(bl_plot, bl_marker, label=label)\n",
    "    plt.legend(loc='lower center', ncol=num_bn+1) \n",
    "\n",
    "    \n",
    "plt.subplot(3, 1, 1)\n",
    "plot_training_history('Training loss','Iteration', solver, [bn_solver], \\\n",
    "                      lambda x: x.loss_history, bl_marker='o', bn_marker='o')\n",
    "plt.subplot(3, 1, 2)\n",
    "plot_training_history('Training accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "plt.subplot(3, 1, 3)\n",
    "plot_training_history('Validation accuracy','Epoch', solver, [bn_solver], \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-o', bn_marker='-o')\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and initialization\n",
    "We will now run a small experiment to study the interaction of batch normalization and weight initialization.\n",
    "\n",
    "The first cell will train 8-layer networks both with and without batch normalization using different scales for weight initialization. The second layer will plot training accuracy, validation set accuracy, and training loss as a function of the weight initialization scale."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running weight scale 1 / 20\n",
      "Running weight scale 2 / 20\n",
      "Running weight scale 3 / 20\n",
      "Running weight scale 4 / 20\n",
      "Running weight scale 5 / 20\n",
      "Running weight scale 6 / 20\n",
      "Running weight scale 7 / 20\n",
      "Running weight scale 8 / 20\n",
      "Running weight scale 9 / 20\n",
      "Running weight scale 10 / 20\n",
      "Running weight scale 11 / 20\n",
      "Running weight scale 12 / 20\n",
      "Running weight scale 13 / 20\n",
      "Running weight scale 14 / 20\n",
      "Running weight scale 15 / 20\n",
      "Running weight scale 16 / 20\n",
      "Running weight scale 17 / 20\n",
      "Running weight scale 18 / 20\n",
      "Running weight scale 19 / 20\n",
      "Running weight scale 20 / 20\n"
     ]
    }
   ],
   "source": [
    "np.random.seed(231)\n",
    "# Try training a very deep net with batchnorm\n",
    "hidden_dims = [50, 50, 50, 50, 50, 50, 50]\n",
    "num_train = 1000\n",
    "small_data = {\n",
    "  'X_train': data['X_train'][:num_train],\n",
    "  'y_train': data['y_train'][:num_train],\n",
    "  'X_val': data['X_val'],\n",
    "  'y_val': data['y_val'],\n",
    "}\n",
    "\n",
    "bn_solvers_ws = {}\n",
    "solvers_ws = {}\n",
    "weight_scales = np.logspace(-4, 0, num=20)\n",
    "for i, weight_scale in enumerate(weight_scales):\n",
    "  print('Running weight scale %d / %d' % (i + 1, len(weight_scales)))\n",
    "  bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization='batchnorm')\n",
    "  model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "\n",
    "  bn_solver = Solver(bn_model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  bn_solver.train()\n",
    "  bn_solvers_ws[weight_scale] = bn_solver\n",
    "\n",
    "  solver = Solver(model, small_data,\n",
    "                  num_epochs=10, batch_size=50,\n",
    "                  update_rule='adam',\n",
    "                  optim_config={\n",
    "                    'learning_rate': 1e-3,\n",
    "                  },\n",
    "                  verbose=False, print_every=200)\n",
    "  solver.train()\n",
    "  solvers_ws[weight_scale] = solver"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff6444eacf8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot results of weight scale experiment\n",
    "best_train_accs, bn_best_train_accs = [], []\n",
    "best_val_accs, bn_best_val_accs = [], []\n",
    "final_train_loss, bn_final_train_loss = [], []\n",
    "\n",
    "for ws in weight_scales:\n",
    "  best_train_accs.append(max(solvers_ws[ws].train_acc_history))\n",
    "  bn_best_train_accs.append(max(bn_solvers_ws[ws].train_acc_history))\n",
    "  \n",
    "  best_val_accs.append(max(solvers_ws[ws].val_acc_history))\n",
    "  bn_best_val_accs.append(max(bn_solvers_ws[ws].val_acc_history))\n",
    "  \n",
    "  final_train_loss.append(np.mean(solvers_ws[ws].loss_history[-100:]))\n",
    "  bn_final_train_loss.append(np.mean(bn_solvers_ws[ws].loss_history[-100:]))\n",
    "  \n",
    "plt.subplot(3, 1, 1)\n",
    "plt.title('Best val accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best val accuracy')\n",
    "plt.semilogx(weight_scales, best_val_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_val_accs, '-o', label='batchnorm')\n",
    "plt.legend(ncol=2, loc='lower right')\n",
    "\n",
    "plt.subplot(3, 1, 2)\n",
    "plt.title('Best train accuracy vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Best training accuracy')\n",
    "plt.semilogx(weight_scales, best_train_accs, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_best_train_accs, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "\n",
    "plt.subplot(3, 1, 3)\n",
    "plt.title('Final training loss vs weight initialization scale')\n",
    "plt.xlabel('Weight initialization scale')\n",
    "plt.ylabel('Final training loss')\n",
    "plt.semilogx(weight_scales, final_train_loss, '-o', label='baseline')\n",
    "plt.semilogx(weight_scales, bn_final_train_loss, '-o', label='batchnorm')\n",
    "plt.legend()\n",
    "plt.gca().set_ylim(1.0, 3.5)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 15)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 1:\n",
    "Describe the results of this experiment. How does the scale of weight initialization affect models with/without batch normalization differently, and why?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Batch normalization and batch size\n",
    "We will now run a small experiment to study the interaction of batch normalization and batch size.\n",
    "\n",
    "The first cell will train 6-layer networks both with and without batch normalization using different batch sizes. The second layer will plot training accuracy and validation set accuracy over time."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    }
   ],
   "source": [
    "def run_batchsize_experiments(normalization_mode):\n",
    "    np.random.seed(231)\n",
    "    # Try training a very deep net with batchnorm\n",
    "    hidden_dims = [100, 100, 100, 100, 100]\n",
    "    num_train = 1000\n",
    "    small_data = {\n",
    "      'X_train': data['X_train'][:num_train],\n",
    "      'y_train': data['y_train'][:num_train],\n",
    "      'X_val': data['X_val'],\n",
    "      'y_val': data['y_val'],\n",
    "    }\n",
    "    n_epochs=10\n",
    "    weight_scale = 2e-2\n",
    "    batch_sizes = [5,10,50]\n",
    "    lr = 10**(-3.5)\n",
    "    solver_bsize = batch_sizes[0]\n",
    "\n",
    "    print('No normalization: batch size = ',solver_bsize)\n",
    "    model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=None)\n",
    "    solver = Solver(model, small_data,\n",
    "                    num_epochs=n_epochs, batch_size=solver_bsize,\n",
    "                    update_rule='adam',\n",
    "                    optim_config={\n",
    "                      'learning_rate': lr,\n",
    "                    },\n",
    "                    verbose=False)\n",
    "    solver.train()\n",
    "    \n",
    "    bn_solvers = []\n",
    "    for i in range(len(batch_sizes)):\n",
    "        b_size=batch_sizes[i]\n",
    "        print('Normalization: batch size = ',b_size)\n",
    "        bn_model = FullyConnectedNet(hidden_dims, weight_scale=weight_scale, normalization=normalization_mode)\n",
    "        bn_solver = Solver(bn_model, small_data,\n",
    "                        num_epochs=n_epochs, batch_size=b_size,\n",
    "                        update_rule='adam',\n",
    "                        optim_config={\n",
    "                          'learning_rate': lr,\n",
    "                        },\n",
    "                        verbose=False)\n",
    "        bn_solver.train()\n",
    "        bn_solvers.append(bn_solver)\n",
    "        \n",
    "    return bn_solvers, solver, batch_sizes\n",
    "\n",
    "batch_sizes = [5,10,50]\n",
    "bn_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('batchnorm')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3QAAAJcCAYAAACxGOZUAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAAIABJREFUeJzs3Xl8XHd97//Xdzbtu0Ya2ZIt77tkO2PnJiEQCCQUQwKJk4Y0aXMvEJYb8AO4vbf0B8TQFrreXLcFWkr7oLfcAsEBEjCUlrZsSUgsb4qXxEkcL3K079Y22/f3xxmNZrRZlmSNJL+fj4ceM3POmXO+Z5TIeuvzXYy1FhEREREREVl4XOlugIiIiIiIiEyPAp2IiIiIiMgCpUAnIiIiIiKyQCnQiYiIiIiILFAKdCIiIiIiIguUAp2IiIiIiMgCpUAnIpJGxhi3MeaSMWbZbB4rEzPGlBtjXjTGZKTh2r8yxjw019e9WowxDcaYW+LPP2OM+ZurcI2vGWN+fxbOc5cx5huz0SYRkflEgU5E5ArEA9XwV8wYM5D0+reu9HzW2qi1Ntdae342j5VJ/T7wNWvtECRC1mD8e9htjPm5MWbTVE5kjPEYY6wxpnq2G2mMeWv83PtGbf+1MeaB2b7eTFlr/8Ba+6GZnMMY835jzM9Gnff91tovzKhxju8B1031eysislAo0ImIXIF4oMq11uYC54F3JW37f6OPN8Z45r6VC89cfU7GmCzgQWD09+pD8e9pCfA08I9z0Z4p6AX+mzGmaqYnutb/W7TWWuBbwAfS3RYRkdmkQCciMouMMX9ojPm2Meabxphe4AFjzA3xqkqXMabRGPOXxhhv/PiUCo8x5hvx/T82xvQaY541xqy40mPj+3/DGHM6XnX6K2PM0xN195usjfH9W4wxPzXGdBhjmowx/zOpTZ8xxrxqjOkxxtQZY5YYY1YbY+yoayS6G8YrMb+IX6cD+LQxZo0x5j+NMe3GmDZjzD8ZYwqS3r/cGPN9Y0xrfP8+Y0xmvM0bko6rMMb0G2NKxrnVG4AWa23jeJ+DtTaC80v/xil+Nr+IP56IV/jujr/nLmPM0fhn8oox5raky6wwxjwT/579izGmeLy2xHUA3wA+O95OY4zLGPNZY8w5Y0yLMebrxpj8+L7V8f9e/qsx5jzwr0nbHjJOd8kOY8wHjDHXG2NeiN/jvqTzT/o9GdWWPzTGfD3+/G9MajU7Yoz5dHzfp40xZ+L3f8IYc0d8+xbgr4Gb4+9pi2//hjFmb9J1PhT/TNvj/z1UxLcP///xwfj+TmPMX45q5s+AXZN83iIiC44CnYjI7HsP8M9AAfBtIALsAUqBm4C3Ax+c5P33A58BinGqgH9wpccaY8qAx4HfjV/3NWDnJOeZsI3xX+B/CvwAqADW4vxiTPz8u+PHFwLvBwYnuU6yG4FTgB/4E8AAfxi/xkZgZfzehqtLB4BXgGqgCnjcWjsYv8/kLoj3Az+x1raPc80twEsTNcgY4wN+C/h10ubJvn9vjD9uildpnzDG3Aj8A/BJnM/kzcC5Ue37HaAcyAE+MVF74v4QuM8Ys3qcfe/HufdbgFVAEbBv1DFvBNaTGmSC8eMfAP4S+D3gLcBmnD9C3BQ/bsLvyWSstR9KqmS/CegEnorvPo3zORYAfwT8szGm3Fr7AvAI8Mv4e0tHnzcejD+P89/cUuB1xlZb3wFcB2yL38tbk/adAlYbY7Ivdw8iIguFAp2IyOz7lbX2B9bamLV2wFp70Fr7nLU2Yq09A3wV55fciey31tZZa8M4v6xuncax7wSOWmufjO97DGib6CSXaeMdwAVr7T5r7ZC1tsda+3x83/uB37fWvhy/36PW2o7JP56E89bar8THBg5Ya09ba//dWhuy1rbE2zzchhtwAtX/stb2xY9/Or7vH4H7jTEm/vpB4J8muGYhTjfG0b5sjOkCLgEP44SGqXw243kf8Hfxe4lZay9Ya5ND5N/HP69+4DtM/v3FWnsR+Dvgc+Ps/i3gz621r1lre3HGB95vjEn+9/1Ra22/tXYgadsfxL+XPwJCwDesta3W2gbgVzhhiMt8Ty7LGFOOM3btw9ba+vg5H7fWNsY/m38GzuIEzKn4LZzxj0fjYf73gDcZYyqTjvmitbbbWnsW5w8PyZ/v8Pe+cKr3ICIy313T/elFRK6SC8kvjDHrgb/AqRpk4/zsfW6S9zclPe8Hcqdx7JLkdlhrrTGmYaKTXKaNVTiVsfFUAa9O0r7JjP6cAjjVopuAPJw/OrYmXeestTY6+iTW2qeNMRHgDcaYTmAZTjVvPJ3xc4/2EWvt1+NB6GbgSWPMTdbaE9P4/lUBByfZfyXf32FfBF4xxmwetX0JqdW/c4APp+o5LOVzBrDWNie9HABGv86Fy35PJhWvdj4BfN1auz9p+0PAx4Hl8U25OGF9KpYAzyTdR0/8e76Ukc91ss93+HvfNcXriYjMe6rQiYjMPjvq9d8Cx4HV1tp8nPFQZsy7ZlcjkKhaxKtXSyc5frI2XsDpnjeeifb1xa+b3LUtMOqY0Z/TnwBDwJZ4Gx4a1Yblxhj3BO34vzjdBx/E6Yo5NMFx9ThdRscVrxr9HKeL6tvimyf7bEbfw3BbJ/q8psVa2wr8FUmVw7jXGQlG4ITZEEmhKz4ZyHRN9j25nC/hVIUfHd5gjFkJfAX4MFBirS0EXmTyzzNZyv0aY/JwuplenGKbNgCvxKujIiKLggKdiMjVlwd0A33xyTsmGz83W34IbDfGvCs+/mwPqVWbK2njU8AyY8wjxhifMSbfGDM8Hu9rwB8aY1YZx9b4JB9N8a8HjLN+3sOkBo+J2tAHdBtnVsf/kbTvWaAd+IIxJtsYk5U0zgucLpa7ccan/d9JrvEs4I9XnsYVP+964ERSu8b9bOIVw3acsWXD/h54vzHmzfFJSyqNMesmu/Ep+nOcsXJrkrZ9E/iEMaY6Hm7+CPimtTY2C9eDyb8nEzLG/HecbrIPjgqUuTihrdU5zLwf57Me1gxUmqQJeUb5JvA+Y0yNcdYR/CLOmLsJq8+jvAn48RSPFRFZEBToRESuvk/iTILRi1Pt+fbVvmC8S91vAv8bJ3CsAo7gVFuuqI3W2m6catXdQAvOpBbD46j+DPg+8O9AD874ssz4L/EfwBnT1QasZvJuiuBUcnbihKencLrrDbchgjMucANOBew8ToAb3n8WeAEIWWufYQLxyt0/4YzFSpaYlRH4Os5YvX+73GeT1O5/js8QeVf8+h/A6arYDfwnTjfMGbHWduGEuuRZMf8u3p5fAmfibdwz02slmfB7chnvxQmejUkzXf7P+Di6vwSex6kiryf1v4t/A14Gmo0xTaNPaq39F5wq5ffi71/G2O/luOJV6vtw/hsVEVk0zMx6YoiIyEIQ76r4OrDbWvvLdLfnajDG/F/gjLV272WOKyc+WcYkXTNlkTHGvAe4x1p7f7rbIiIymxToREQWKWPM23G6GA4Cn8KpGq1cjCEmPjbrCM5Yr/Ppbo+IiMhcUZdLEZHF6w043fDacNZOe/ciDXNfBI4BX1CYExGRa40qdCIiIiIiIguUKnQiIiIiIiIL1LxbWLy0tNRWV1enuxkiIiIiIiJpcejQoTZr7WTLDSXMu0BXXV1NXV1dupshIiIiIiKSFsaYc1M9Vl0uRUREREREFigFOhERERERkQVKgU5ERERERGSBUqATERERERFZoBToREREREREFigFOhERERERkQVKgU5ERERERK4pB84c4Lb9t1HzjzXctv82Dpw5kO4mTdu8W4dORERERETkajlw5gB7n9nLYHQQgMa+RvY+sxeAXSt3pbFl06MKnYiIiIiIXBNiNsZjhx5LhLlhg9FB9h3el6ZWzYwqdCIiIiIisiBZa+kL99Ex2EHHYAftg+10DHbQOdjpbBtwtncMOc+7hrqI2ui452rqa5rj1s8OBToREREREZk3BiIDI4Es+WtUOBveHo6Fxz1PnjeP4qxiijOLqcqtotZfS3FmMd968Vv0hHrGHB/ICVztW7sqFOhEREREROSqCUfDdA4lVcxGBbLh8DZcXRuIDIx7nkx3JiVZJRRlFOHP9rOueB3FmcVjvooyiyjOLMbn9o17npUFK1PG0A2fe8/2PVfl/q82BToREREREZmyaCxKd6h7wopZcnWtfbCd3lDvuOfxuDwUZxQnqmjL8pclwlhJZsmYgJbtzZ6V9g9PfLLv8D6a+poI5ATYs33PgpwQBRToREREREQWvANnDkw7oFhr6Q330jHQ4VTSBsYZi5b01TXURczGxpzHZVwUZhQmgtj64vWJMDYc0hKvs4rJ8+ZhjJntj2JKdq3ctWAD3GgKdCIiIiIiC9hE0/C3D7SzrWxbSrVs3LFpgx1EYpFxz53ny0tUy5bnL2db2bZxuzkWZxVT4CvA7XLP5a0LCnQiIiIiIguGtZaeUA9NfU009jXS2NfIvsP7xp2G/8/q/mzM+7M8WYlqWXl2ORuKN6R0bSzJLEl0gSzKKMLr9s7Vrck0KdCJiIiIiMwTQ9EhmvuaE2Gtqa8pEd6GHyeaNGQ8X7r1S4mwVpRRNGvj0GT+UKATEREREZkDMRujfaA9JZyNfuwY7BjzvpLMEipyKlhVuIobl9xIRU4FFbkVBLIDVORWcP+B+2nsaxzzvoqcCt5Y+ca5uDVJIwU6EREREZFZcCl0aUxIS+4a2dzfPGasWrYnm4qcCgI5AdYXr088r8ipoCKngvKc8gmn3x+2Z/ueRTUNv1wZBToRERERkcsIx8K09LfQeGkknA0/b+xrpLmvmd5w6vT8buOmPLucQE6AWn9tSlgL5AQI5ATI9+XPeKbHxTYNv1wZY61NdxtSBINBW1dXl+5miIiIiMg1wlpL51CnU1W71ERTf1MirDX1N9F0qYnWgVYsqb83F2UUJYLZeGHNn+XXrI8yLcaYQ9ba4FSOVYVORERERBa1/nB/Ipg19ce7QF6Kh7V4t8ih6FDKezLcGYlwduPSG1O6QA5vz/JkpemOREYo0ImIiIjIvDPVhbIjsQhtA20pY9VGj2HrGupKeY/B4M/2U5FTwfri9by56s0plbaKnAoKMwrTtui1yJWYUaAzxrwd2Ae4ga9Za/941P5lwD8ChfFjfs9a+6OZXFNEREREFrfxFsr+zNOf4dnXn6UkqyQlrLX0txC10ZT35/nyEuGs1l87Jqz5s/14XVpfTRaHaQc6Y4wb+BLwNqABOGiMecpaezLpsE8Dj1trv2KM2Qj8CKieQXtFREREZJEaig5xsv0kX3juC2MWyg7Hwjz56pN4XV7Ks8upyK1gR2BH4nlFjjONfyAnQK4vN013IDL3ZlKh2wm8Yq09A2CM+RZwJ5Ac6CyQH39eALw+g+uJiIiIyCJhreXipYvUt9ZzrPUY9a31vNj54php/ZMZDHUP1OEyrjlsqcj8NpNAtxS4kPS6Abh+1DF7gX81xnwUyAHeOt6JjDEPAw8DLFu2bAZNEhEREZH5qD/cz4n2E4nwVt9aT/tgOwBZniw2l27mdzb+DjX+Gr7w3Bdo7m8ec45ATkBhTmSUmQS68UaJjl4D4b3A1621f2GMuQH4J2PMZmttLOVN1n4V+Co4yxbMoE0iIiIikmbWWs73nk+Et2Otx3i58+XEWLfq/GpuWnoTtf5aavw1rC5cjcc18mvpQGRAC2WLTNFMAl0DUJX0upKxXSrfB7wdwFr7rDEmEygFWmZwXRERERGZRy6FLvFC2wsj3Sfb6uke6gYgx5vDltItvH/L+6nx11BTWkNhZuGk59NC2SJTN5NAdxBYY4xZAVwE7gPuH3XMeeBW4OvGmA1AJtA6g2uKiIiISBrFbIzXul9Lqb692vVqYtHtVQWruHXZrdSU1lDjr2FlwcppLa69a+UuBTiRKZh2oLPWRowxjwA/wVmS4B+stSeMMZ8H6qy1TwGfBP7OGPNxnO6YD1lr1aVSREREZIHoHup2xry1OePeXmh9gd5wLwD5vnxq/DXcVn0btaW1bPZvJt+Xf5kzishsMvMtXwWDQVtXV5fuZoiIiIhcc6KxKK90vZJSfTvbcxYAl3GxpnANNf6axNi35fnLNUmJyFVgjDlkrQ1O5dgZLSwuIiIiIgtXx2BHYsbJY63HON52nP5IPwDFmcXUlNZw5+o7qSmtYVPpJnK8OWlusYiMpkAnIiIicg0Ix8Kc7jzNsZZjie6TF3qdFag8xsPa4rVOePPXUFtaS2VeJcaMN6m5iMwnCnQiIiIii1Brf2tK18mT7ScTywD4s/zU+mu5Z+091Phr2FiykSxPVppbLCLToUAnIiIissCFoiFOdZxK6T7Z2NcIgNflZUPJBnav3U1tWS21pbUEcgKqvoksEgp0IiIiIguItZamviaOtR1LdJ881X6KcCwMQEVOBTX+Gh7c+CA1/ho2FG/A5/aludUicrUo0ImIiIjMY4ORQU62n0x0n6xvradloAWADHcGm0o28cCGB5xFu/01lGWXpbnFIjKXFOhERERE5sCBMwfYd3gfTX1NBHIC7Nm+Z8zC2dZaGi41pIS3lzpeImIjAFTlVbGjYgc1pTXUltWytmgtXpc3HbcjIvOEAp2IiIjIVXbgzAH2PrM3MSlJY18je5/Zy1BkiMq8Surb6hMhrmOwA4AsTxZbSrfw0OaHqPXXsqV0CyVZJem8DRGZhxToRERERK6yfYf3JcLcsMHoII8++2jidXV+NW9Y+gZq/bXU+mtZVbgKj0u/qonI5PRTQkREROQqsNZyruccB5sPJmacHM+Xb/0yNf4aCjIK5rB1IrJYKNCJiIiIzAJrLa91v8bBpoPUNddR11xH20AbAC7jImZjY95TkVPBzZU3z3VTRWQRUaATERERmYaYjfFq16vUNddxsOkgh5oPJca/lWWXsTOwk2AgyI7yHRxvO87nnv1cSrfLTHcme7bvSVfzRWSRUKATERERmYKYjfFy58tO9a3JqcB1DXUBEMgJcNOSmxIBrjKvMmXh7uqCaowxl53lUkTkSinQiYiIiIwjGovyUudLifB2qPkQPaEeAJbmLuVNlW8iGAgSLA+yNHdpSoAbz66VuxTgRGTWKdCJiIiIAJFYhJc6XkqMgTvcfJjecC/grP9267Jb2RHYQbA8SEVuRZpbKyLiUKATERGRa1I4FuZU+6nEGLgjLUfoC/cBzhICt1XflqjABXICaW6tiMj4FOhERETkmhCOhjnRfiIxBu5wy2EGIgMArCxYya4VuxIBzp/tT3NrRUSmRoFOREREFqVQNMQLbS8kxsAdaz2WCHCrC1dz56o7CQaCXFd+HaVZpWlurYjI9CjQiYiIyKIwFB2ivrU+JcANRYcAWFu0lrvW3EWwPMj28u0UZxanubUiIrNDgU5EREQWpIHIgBPg4mPgXmh9gVAshMGwvng996y9hx2BHVxXfh0FGQXpbq6IyFWhQCciIiILQn+4n6OtR6lrcpYQqG+rJxKL4DIuNhRv4L3r30sw4FTg8n356W6uiMicmFGgM8a8HdgHuIGvWWv/eNT+x4A3x19mA2XW2sKZXFNERESuDX3hPo60HEl0oTzRdoKIjeA2bjaVbOLBjQ8SLA+yrWwbeb68dDdXRCQtph3ojDFu4EvA24AG4KAx5ilr7cnhY6y1H086/qPAthm0VURERBax3lBvSoA72X6SqI3iMR42lW7ioc0PESwPsrVsKznenHQ3V0RkXphJhW4n8Iq19gyAMeZbwJ3AyQmOfy/w6AyuJyIiIotIT6iHw82HEwt5v9jxIjEbw+PyUFNaw/u2vI9geZBafy3Z3ux0N1dEZF6aSaBbClxIet0AXD/egcaY5cAK4D8m2P8w8DDAsmXLZtAkERERma+6h7oTa8DVNdfxUsdLWCw+l48afw0P1zzMjvId1PhryPRkpru5IiILwkwCnRlnm53g2PuA/dba6Hg7rbVfBb4KEAwGJzqHiIiIzCMHzhxg3+F9NPU1EcgJsGf7Hnat3JXY3zHYwaHmQ4kAd7rzNAAZ7gy2+rfy4a0fJlgepMZfQ4Y7I123ISKyoM0k0DUAVUmvK4HXJzj2PuC/z+BaIiIiMo8cOHOAvc/sZTA6CEBjXyOPPvMox1qPEbMxDjUf4pWuVwDI8mSx1b+Vj277KMHyIJtLN+Nz+9LZfBGRRWMmge4gsMYYswK4iBPa7h99kDFmHVAEPDuDa4mIiMg8su/wvkSYGzYUHeKbL36TbE8228q2sWvlLoLlQTaVbMLr9qappSIii9u0A521NmKMeQT4Cc6yBf9grT1hjPk8UGetfSp+6HuBb1lr1ZVSRERkAesa7KKuuY7nGp+jsa9x3GMMhqff+zQel5a6FRGZCzP6aWut/RHwo1HbPjvq9d6ZXENERETSozfUy6HmQzzX+BwHmw5yuvM0FkuWJ4sMdwZD0aEx7wnkBBTmRETmkH7iioiICAD94X4Otxzm+cbneb7peU51nCJmY4lJTB7Z9gg7AzvZVLqJfz37rylj6AAy3Zns2b4njXcgInLtUaATERG5Rg1GBjnaejQR4E60nSBiI4l14B6ueZidgZ3jzkI5PJvlZLNciojI1Wfm29C2YDBo6+rq0t0MERGRRScUDVHfWs/BpoM81/Qc9a31hGNh3MbNptJN7AzsZGdgJ1vLtpLlyUp3c0VErlnGmEPW2uBUjlWFTkREZJEKx8KcaDuRCHDHWo4xGB3EYNhQsoHf2vBb7Ajs4Lry68jx5qS7uSIiMg0KdCIiIotENBblxY4Xeb7J6UJ5uPkw/ZF+ANYWrWX32t2JAFeQUZDm1oqIyGxQoBMREVmgYjbGy50vJwLcoaZD9IZ7AVhRsIJ3rXoXOwM7CQaCFGcWp7m1IiLzSP3j8O+fh+4GKKiEWz8LNfemu1XTokAnIiKyQFhrOdN9huebnudg00EONh2ka6gLgKq8Km6rvo2dgZ3sCOzAn+1Pc2tFROap+sfhBx+D8IDzuvuC8xoWZKhToBMREZmnrLWc7z3vBLjGgzzf9Dztg+0AVORU8KbKN7GzwpnIJJATSHNrRUTmUDQCQz3xr14YjD9PPHY721O2xR9bXwIbTT1feMCp2CnQiYiIyEy8fun1xELezzc9T3N/MwD+LD/XV1zP9RXXsyOwg8rcSowxaW6tiMg0RIbiIax7nMDVmxTIkvaNDm3hvstfx+2DjHzIzB95zFkJLSfHP767YXbvc44o0ImIiKRRc19zogvl803Pc/HSRQCKM4sJlgedpQQqdlKdX60AJyITm4sxYdY6lawxlbArrJJFhy5/LW92UhjLc57nL4lvKxi7LxHa4vsy8sCbOf65H9vsdLMcraByZp9PmijQiYiIzKH2gfZEeDvYdJCzPWcByPflEywP8uDGB9kZ2MmqwlW4jCu9jRWRhWEqY8JiMQhdGr8L4rjbhgNad+q2WOTy7cnIHwlVmfmQXQrFK0eFsILUylni+ALn0e29Op8VOGE3+fMC8GY52xcgLSwuIiJyFXUPdVPXVMdzTU43yle6XgEgx5vDdeXXJSYxWVe0DrfLnebWisiC9Nim8bsLujyQGxgJY1zm937jnkLgyp+8SubLA9cC+GPUPJ/lUguLi4iIpElvqJfDzYcTAe6ljpewWDLdmWwv386ulbvYGdjJxpKNeFz6Z1hEpsFa6HwNzvwcXvv5xGO/YhFY8caxwWyi0ObNhmula3fNvYQDt3DxE5+k8rH/jce/cGcG1r8kIiIiM9Af7udIyxEnwDUe5GTHSWI2hs/lo7aslo9s/Qg7AzvZUroF79XsQiQii9ulFnjtF3DmZ06Q6z7vbM9b4gSxcP/Y9xRUwXu+MqfNXEjavvwVBg4dovXLX6Hi0YXZ3RIU6ERERK7IYGSQY63HnMW8G5/neNtxIjaCx3jY4t/CB7Z8gJ2BndSW1ZLhzkh3c0VkoRrqhbNPOxW4Mz8bmZkxswCqb4abPgYr3gSla+CF7yyqMWFXkw2FiLS1MXj6NF1PPAHW0v3d7+L/yIcXbJVOgU5ERCTuwJkD7Du8j6a+JgI5AfZs38Nty2+jvq0+EeDqW+sJxUK4jItNJZv47U2/zfWB69latpVsb3a6b0FEFqrIEDQcHOlG2VDnrJXmyYRl/wW23AMr3wQVW2H0eNvhsV/zeEzY1WbDYSLt7URaWoi0tBBuaSHS2hp/HX9sbSXa0TH2vdHogq7SaVIUERERnDC395m9DEYHE9tcuHAZFxEbwWBYX7yeHYEdXF9xPdvLtpPry01ji0VkQYvFoKk+XoH7OZx7BiIDYFywZLsT3la8Caqun3j6/WuAjURSgtpwSAsnXrcRaWlxgtroXONy4SktxVNWhsfvdx7L/JisLFof+z8QDicONRkZrP7pv82bKp0mRREREZmicCzMibYT/NGv/yglzAHEiJHpzuTP3/DnBANBCjIK0tRKEVnwrIWOM073ydd+7oyHG+h09vnXw/bfdkLc8psgqzCtTZ0LTlDrSAlpznOnohaOP0bb28cPaiUlePx+vOXlZG3ZkhTanODmLSvDXVyMcY+dPbhx7+fGticWW7BVOgU6ERG5poSiIY63HaeuuY6DTQc51nqMgcjAhMcPRAa4dfmtc9hCEVk0eptHKnBnfgY98dko8yth3TucCtyKN0J+RVqbOZtsNOpU1Mbp7pjoDtnaQrS9w6lSJjMGd2k8qPnLyNq0OamyVjYS2kqKMZ7px5iBo0dTqnMAhMMMHDky7XOmkwKdiIgsakPRIepb66lrruNQ0yGOth5lKDoEwJqiNbx79bsJlgf504N/SnN/85j3B3ICc91kEVmoBruTJjL5ObSecrZnFTkTmdz8cVj5ZmeR7QW2PICNxYh2dIzq7tg6NrC1tY0f1IqLE10eMzdtTA1qw89LSmYU1KZq5fe/d9WvMZdm9IkZY94O7APcwNestX88zjH3AntxVjI8Zq29fybXFBERmcxgZJD61noONh+krqkuMYmJwbC2aC33rL2HYHmQ7eXbKcosSrwvHAuPGUOX6c5kz/Y96bgNEVkIwoPQ8PzIRCYXD8cnMsmC5TdA7X1ON8pAzdiJTK5Gc1parnhdNRuLEe3sTBmjlghsLa2pQS0aHfNAT4xZAAAgAElEQVT+5KCWsW5tortjSmArKcF4tWzL1TLtQGeMcQNfAt4GNAAHjTFPWWtPJh2zBvgUcJO1ttMYUzbTBouIiCTrD/dzrPUYdc111DXV8ULbC4RjYVzGxbqidfzm+t9kR/kOtpdvn3QM3K6VuwDGzHI5vF1EhFgUGo+NVODOPwuRQTBuWHod3PwJWHkLVO4Az9wvW5K8rlrgM58m2tU1trvj6MpaWxtEImPO5S4qSlTPMtasSYxN8/j9TmAbDmo+35zfp6Sa9iyXxpgbgL3W2tvjrz8FYK39YtIxfwqcttZ+barn1SyXIiIymeGFvIcD3PA6cC7jYmPxRoKBIMHyINvKt5Hvy093c0VkIbMW2l9JmsjklzDY5ewr2+iMgRueyCRzbn/e2HCYcFMT4YYGQhcuMPTSaTq/+c2R7o4ez/hBrbBw/HFpZUlBrbRUQS3N5mqWy6XAhaTXDcD1o45ZG2/Q0zjdMvdaa/9l9ImMMQ8DDwMsW7ZsBk0SEZHF5lLoEodbDifGwJ1oP0HURnEbN5tKnXXgguVBtpVt0zICIjJzPY0jFbjXfg49F53tBctgwzthxS3ORCZ55Ve1GdZaop2dicAWvtBA+GIDoQsNhC9cINzUlNoF0piR2SCNIWPNGgrvuivRHdLjL8PjL8WVMfeVQ7m6ZhLoxhvJObrc5wHWALcAlcAvjTGbrbVdKW+y9qvAV8Gp0M2gTSIissD1hHo40nyEg00HqWuu41THKWI2hsflYUvpFv7b5v9GsDyohbxFZHYMdMHZX8VD3M+g7bSzPavYCW4r/4fTjbJoxaxPZBIbHCR88eJIYGtoINQQD2wNDcT6+1OOd5eW4qusJGvbNvKrKvFVVuGtrMSVncW5Bx7EDjkTPmEtoTNnyH/77fNmXTW5emYS6BqAqqTXlcDr4xzza2ttGHjNGPMSTsA7OIPriojIItI91M2h5kOJLpQvdryIxeJ1edlSuoUPbPkAwUCQWn8tWZ6sdDdXRBa68CBc+PVIBe71I2Bj4M2G5TfCtgedAFe+GVyuGV3KxmLOuLULF5zKWkMDoYaR8BZpbU053mRl4ausxFtZSfZ/uT4R2HxVlXiXLsWVPf4fsRr3fg47ambJhbyumlyZmQS6g8AaY8wK4CJwHzB6BsvvA+8Fvm6MKcXpgnlmBtcUEZEFrnOwMyXAne48jcXic/moLavlQ7UfYkdgB1tKt5DpyUx3c0VkoYtF4fWj8NrP4hOZ/BqiQ+DywNIgvPF3nbFwlTvAc+XjxqK9vRMGtvDFi9jk9c5cLjyBcnyVVeS88eZ4eKtyAltlJe6SEsw0qoCLbV01uTLTDnTW2ogx5hHgJzjj4/7BWnvCGPN5oM5a+1R8323GmJNAFPhda237bDRcREQWhvaBdg41H0p0oXyl6xXAWRKgtqyWj2z9CMHyIFv8W8hwa2yHiMyQtU63yeEK3NlfOuvDgVN12/H++EQmN0JG3uVPFwoRbmxMBLZwQ3J4ayDW3Z1yvKugAF9lJRnr15P31lvxVlbhrap0wltFxVWZbGSxrasmV2bas1xeLZrlUkRkYWsbaKOuqY665joONh3kTLfTMSPLk8VW/1Z2BHYQDATZXLIZr1vrEonILOi+mDqRSW+js71wuRPeVsS/cseOJ7PWEm1vd8axNVwcFdguEGlqTlko23i9eJcuxVtVhbdyqdMtcjiwVVbiztfsujJzczXLpYiICM19zU73yXgXyrM9ZwHI9mSzrXwbd6y6g2AgyMaSjXhdCnAiMkX1j8O/fx66G6CgEm79LNTc6+wb6HSWEBgOce0vO9uzS+MTmcQDXPEKAGL9/c5kIw3HUwJbuOECoYaL2IGBlEt7/H5nHFswmDqOraoKT1kZZoZj60Rmkyp0IiJyRRovNaYEuPO95wHI9eayvXw7wfIgOwI7WF+8Ho9LfzcUkWmofxx+8DHCPUNcfKaIyhs78eR6YeWboa/ZGROHBW8OVN+EXX4zkdwthAazRmaNbLjojG27eJFoW1vK6V3Z2XgrnYA2XFnzVlXiq6pyJh/J1PhdSS9V6EREZNZcvHTRGf8W70Z58ZKzJlOeL4/ryq/j3nX3EgwEWV+0HrfLnebWisi8FYtCqC/p6xKE+0eeJ2//1WMQHqDtRD4DrT5aj+dSVtNL6Ll/J5y5kZB7F+FQPuHOIUK/uEj49a+lTgriduMNBPBWVZH35lvwLk0KbJWVuIuKpjX5iMh8pEAnIiIJ1loaehsS49/qmuto7HPGohRkFBAsD/LAhgcIBoKsKVyjACeyGFkLkcFRQat/bOgaN5iNsy8U3xcZuPy1k/S1eOl6NQcwdL2aQ9erufE9rUAr7sJCvFVVZG3aRP5tt4+MY6uqwhsIYLzq4i3XBgU6EZFrmLWWcz3nEl0oDzYdpKW/BYCijCKCgSAPbXqIYCDI6sLVuIzGjYhM22RjwqYrGpkkXI0XwCbZl/w+G7v8tYd5s8GXE//KdR4z8iAv4LxO7M8de5wvO2V7LOqh9+fP0vVXn6a/EWBkaFBmyRAl12Xh+8gTTpUtN3fCJolcSxToREQWsQNnDrDv8D6a+poI5AT42LaPsbF0o9N9Mt6FsnXAWdi2JLOEYCCYGAO3smCluiSJzJb4mDDC8SpV9wV48hFoPgFLrxsbssKTVcSS9kWHpt4GlycenpKDVQ7kLxknaCU992aPfU/yvlmYIGTw5Em69n+d7h/8kFhvLx5/IZhOsMM/gwxDXT6yd38Cz/r1M76eyGKiQCciskgdOHOAvc/sZTA6CEBjXyOf+tWnEvvLssoSAS4YCLIif4UCnMhMRMPOdPndDWO/Xv0PiI1a+Dk6BE//n/HPNTpAeXMgsxDyl06p0jUmnHlzprVo9tUU7emh+4c/pHv/EwyePInJyCDv9tso3L2bnh/9mK7934FINHG8NR5a//MiFW9MY6NF5iEFOhGRRaRrsIv6tnqOtR7j68e/TigWGnNMga+A/7fr/7Esb5kCnMhUWQv9HU5lrediPKhdiD/GX19qGttVMavI6V45OswlGPjQr1IDmSdrVqpe85G1loG6Orr276fnX36CHRoiY/16yj/zaQre+U7cBQUANH/hiylhDoBIlIEjR9LQapH5TYFORGSBisQivNz5MvWtToCrb6vnXM85ANzGTdRGx31fT6iH5fnL57KpIvNfqD8pqMW/epKrbBfHTurhznDCWsFSWPVm53n+0vi2Kme7L8c59rHNTgAcraASApuv/v2lWaStje7vf5+u/U8QOnsWV24uBe95N4W77yFz08Yxf1xa+f3vpamlIguPAp2IyALRNtA2Et5a6znRfoKB+C+YxZnF1Pprec/q91Djr2FTySbe/eS7EzNUJgvkBOa66SLpFYtCb1M8sI2qqg1X3PrbR73JOJN65C+F8s2w9u3xoBb/yq+EnFKYapX71s+mjqED8GY52xcpG43S96tf0bV/P73/+TOIRMgKXkfFhz5I/u2348rKSncTRRYFBToRkXkoHA3zUudLHGs9lghww+u/eYyH9cXruWvNXdSU1lDjr2Fp7tIxf+Hes31Pyhg6gEx3Jnu275nTexG5qqyFwe4Jqmrx4Nb7OsQiqe/LyB8JZ0uvS62qFVRC3pLZHXM2PJvlbM9yOQ+FGhro/u536Xriu0Sam3EXF1P8O79N4d13k7FyZbqbJ7LoGGvt5Y+aQ8Fg0NbV1aW7GSIic6q5rzkR3I61HuNk+8nE+Ley7DJq/bWJr/XF68n0ZE7pvKNnudyzfQ+7Vu66mrciMrsiQ0ldIUdV1YZDW+hS6ntcXmfmxuSANlxVG+4imVmQnvtZpGKhEJd++lO69u+n75lnwRhybn4Dhbt3k3fLLRjf/JqQRWS+M8YcstYGp3SsAp2IyNwaig5xqv1USvWtub8ZAJ/Lx8aSjdT4a6j111Ljr1EXSZm/ZrquWiwGfa3jVNWSvvpaxr4vx580Xq1qJKQNP88pW7STisw3g6dP0/3EE3Q/+RTRri68S5ZQcPddFN51F96KinQ3T2TBupJApy6XIiJXkbWW1/teTxn7dqrjFJF496+luUvZXrad2rJaakprWF+8Hq/bm+ZWi0zBeOuq/eBjzvPhUDfUO3FVrbvBeR0dNROrN3ukohbYnFRVG66yLXHGnknaxPr66Pnxj+n6zn4Gjh0Dr5e8t95K4e7d5NxwA0ZhWmROqUInIjKL+sP9nGw/mQhv9W31tA20AZDlyWJTySZq/DWJClxpVmmaWywyTRPN2ujJhJLVzr7B7tR9xg15FUkBLamqNjw7ZFbR1CcakTljrWXw2DG6nniCngM/Itbfj2/1Kgp376bgjjvwFBenu4kii4oqdCIic8Bay/ne8ynVt9OdpxPLBSzPX84NFTckwtuaojV4XPqxKwtQeABaX4LWF6HlJLS8OH6YA4gMQuEyWHZDamWtoBJyA+DW/wMLSaSzk56nnqJr/36GXn4Fk5VF/jt+g8Ldu8naulVrWYrMA/qpKiIyRZdClzjefjwlwHUNdQGQ481hc+lm3rflfdT6a9lSuoWizKI0t1jkCkVC0P4ytJxyvoYDXMdrQLxHj9sHJWucrpHh/rHnKKiC935zTpsts8vGYvT/+tfOcgP/9lNsOExmTQ2Bz3+O/He8A3dubrqbKCJJFOhERMYRszHOdp8dmbikrZ5XOl/Bxn+pXVmwkjdXvTnRfXJVwSrcLneaWy0yRdEIdJyB1lMj4a3lFHS8OjK9v3FDySoIbIEt90LZBuereCW4vWPH0MGiX1dtsQs3NdH9ve/Rtf8Jwhcv4i4ooPC991F4924y161Nd/NEZAIKdCIiQPdQNy+0veCMe4uPfesN9QKQ58ujxl/D25a9jVp/LZv9m8n35ae5xSJTEItB11mni2TLyXjF7RS0nU6ajMRAUTWUbYQN73Qe/euhdA14MiY+9zW0rtpiZsNhen/2M7r3P8GlX/4SYjGyb/gv+D/xcfLe+lZcGZP8NyAi84ICnYhcc6KxKK90vUJ9W32i++Rr3a8B4DIuVheu5vbq2xPLBlTnV+MymrVN5jFrnRkjW06NjHFrOekEt+RukQVVTpVt1Vuc4Fa2HkrXgS97etetuVcBboEaeu01up94gq7vP0m0rQ1PWRklD3+AwrvvxldVle7micgVUKATkUWvY7CDF1pfSIx7e6HtBfojzi+5RRlF1PhreNfKd1Hjr2Fz6WZyvDlpbrHIBKyFSy1J1bZ4eGt9EYZ6Ro7LDThh7bqHnGpb2Ubwr4NMVZavZbGBAXr/9V/p+s5++uvqwO0m95ZbKNx9N7k334zx6NdCkYVoRv/nGmPeDuwD3MDXrLV/PGr/Q8CfARfjm/7aWvu1mVxTRK5tB84cYN/hfTT1NRHICbBn+x52rdyV2B+OhXm58+WRZQNa6znfex4At3Gzrngdd6y6gxp/DVv9W6nMq9QsbTI/9XfEA9uoCUoGOkeOySp2wlrNbzoBbri7ZLamkJcRAydOOIt//+CHxHp78S5fhv+Tn6DgzjvxlpWlu3kiMkPTDnTGGDfwJeBtQANw0BjzlLX25KhDv22tfWQGbRQRAZwwt/eZvQxGBwFo7Gvk0Wce5XjbcbxuL/Wt9ZxoO5HYX5pVSq2/lrvX3k2tv5aNJRvJ8mhBYplnBrvjVbZRE5T0tYwck1HgBLaNd4J/w8gEJTl+rdkm44r29ND9wx86yw2cPIXJyCDv9tso3L2b7B079IcskUVkJhW6ncAr1tozAMaYbwF3AqMDnYjIrNh3eF8irA0big7xjVPfwOPysLF4I7vX7k6MfavIqdAvLTJ/hPriVbZRE5T0XBw5xpvtVNjWvG0ktPk3QP4SBTe5LGstA3V1dO3fT8+//AQ7NETG+vWUf+bTFLzznbgLCtLdRBG5CmYS6JYCyauKNgDXj3Pc3caYNwKngY9ba8esRGqMeRh4GGDZsmUzaJKILCaXQpeob63ncMthjrYcpbGvccJjf33/r8lwazY2mQfCg0lruSVNUNJ1npG13DLAvxaW3zQS3Mo2QMEycGkCHrkykdZWup98kq7v7Cd07hyu3FwK3vNuCnffQ+amjfrDlsgiN5NAN95PBzvq9Q+Ab1prh4wxHwL+EXjLmDdZ+1XgqwDBYHD0OUTkGtHU18Th5sMcaTnC0dajnO48TczGcBkX64rWke3JTkxmkqwip0JhTmZH/eNTn4Y/Gob2V8dOUNLxKtiYc4zL4yzCvXQ7bHtgZIKSompwawIKmT4biXDpV7+ia/9+Lv3s5xCJkBW8jooPf4j822/HlaXu5SLXipn8a9IAJM9rWwm8nnyAtbY96eXfAX8yg+uJyCISjUV5uetljrQc4UjzEY60HqGprwmAbE82Nf4aPljzQbaVbaPGX0OON2fMGDqATHcme7bvSddtyGIyeqHs7gvOaxuDyh2p1bbWF6HtZYiFnWONy1lw278eNr1nZIKS4lXg8aXvnmTRCTU00PXEE3R/93tEmptxFxdT/Du/TeHdd5OxcmW6myciaTCTQHcQWGOMWYEzi+V9wP3JBxhjKqy1w32k7gBOzeB6IrKA9Yf7qW+rd6pvLUc51nqMvnAfAGXZZWwv287WTVvZVraNtUVr8bjG/ngans1yslkuRaYlFoV/e3QkzA0LD8D3Ppi6rXCZE9bW3Ja0ltta8KoiIldHLBTi0k9/Stf+/fQ98ywYQ87Nb6D8//t98m65BePTHw1ErmXTDnTW2ogx5hHgJzjLFvyDtfaEMebzQJ219ingY8aYO4AI0AE8NAttFpEFoKW/xam+xb9e6niJqI1iMKwpWsM7V76TbWXb2Fa27YomL9m1cpcCnFyZSAh6G6HndWcCkuTnPa9DT6OzzUYnPsedX3ImJ/Gvg4zcuWv7AhBuaeHiJz5J5WP/G4/fn+7mLCqDp087yw18/0mi3d14lyyh9KOPUHjXXXgrKtLdPBGZJ4y182vIWjAYtHV1deluhohcgZiN8WrXqykB7uIlZ+a+THcmW/xbEuGtxl9Dvk+LG8ssGboUD2gXnWA2HNJ6k573tY59nzfHmTky+avuH1LXeBtWUAUfP37172WBatz7Obq+/W0K77uPikc/m+7mLHjRS330/PhHdO3fz+CxevB6yXvrrRTu3k3ODTdgNGmOyDXBGHPIWhucyrEakS0iV2wgMsDxtuMcbTnK4ZbDHGs9Rm+oF3DWfttWto3719/P9vLtrCteh9flTXOLZcGx1glXo8PZ6K+h7rHvzSqC/KWQVwEVW53n+RXx4BbfnlkwdhkA//rUMXTgdKO8VSElWbS3l9DZc4TOnWPwxAm6Hn8crKXr298m2tGBu7AQV2YGxpeByczAlZmJych0tmVkJm1LeszIwIzadi0FF2stg8eO0bl/Pz0/+jG2vx/f6lWU/d7/ouCOO/AUa6F4EZmYAp2IXFbbQBtHW44mxr+dbD9JxEYAWFWwiturb3cqcP5tVOZVaopsmVws5lTNkkNa7zhhLTJqPBsGcsudcFayClbc7ISz/KUjVba8CvBlT69dw7NZTnWWy0UsNjhI6Nx5QufOxsNb/PHsWaLt7RO8KcalX/4SV1YWdnCQ2NAQRCLTboPx+TCZmUlhz4crIzNlW0pITA6Lw2EyJUCOHO/KjJ/Tl5H03DcnP7uSu6ji8dDz1FPO4t8vv4LJyiL/Hb9B4e7dZG3dqp+lIjIl6nIpIimstbzW/RpHWo4k1n8733seAJ/Lx+bSzWwr28b28u3U+mspyNBCtZIkEoJLTUlj1MYZu9bbCLFRv+i7vPFwtmTsV97wYwDcqvbOFhsOE2poIHTOCWrJj5HXU9d8dJeW4qtejq+6Gt9y59GVl0fDBz+EHRpKHGcyMlj9039LjKWzkQixwSHs0GAi5NmhIWKDgyOP8f2x5MfBQWxoaMy22JBz/PCjHRpyzjl87sFB5w8G02FMarUwEQgzccXDZUpIHN6XHBIzMsYPjhkjobL1r/+aniefxFtVRaSxERsOk1lTQ+Huu8l/xztw52qMpoioy6WIXIGh6BAn2k4kqm9HWo/QHe/GVpRRxNayrdyz9h62lm1lY8lGfG7NpnbNCvXFJxB5feykIinj1Ub9odCbPRLOlt80TmhbCtmlWlD7KrCxGJHGRkLnzjF09izh4cez5wg1NEB0ZCIYV34+vupqsq8L4rt7OLxV46tePm7IaNz7Oeyo8GRjMVq//JXEWDrj8eDO9UBuztW90eHrWwvhcGrISwqQdnBUcBwajO8LTR4cBweJdndjW1K3JULkNITPn6fgnt0UP/AgmevWzvInISLXEgU6kWtM52BnovvkkZYjnGg/QTi+llZ1fjVvqXpLYgKT5fnL1eVnoZvKQtnWwmBXajVtvG6Qg11jz59ZODJGraJmZIxacjfI8caryayx1hJtb3eqa8mVtrPnCJ0/n1pBy8rCt3w5GevXk/f2tyeqbb4V1bgLC6/o//eBo0chHE7dGA4zcOTILN3ZlTPGgM+H2+eDvLw5uaa1FhsKjYTF0MTBsevbj9N/6JATpL1ejMerMCciM6YulyKLmLWW873nOdx8mKOtRzncfJizPWcB8Lg8bCrZ5Kz/VraVrWVbKc7UwPtFZfRC2eB0bVz9VidkJXeDDPePerOB3LJR4Sz5+dKZjVeTKxbt6RkJbK+lhrdYX9/IgV4vvqqqkbCWFNo8ZWX6I02ahFtaePVtt03aRVVEZJi6XIpco8LRMCc7TjqzT8ZDXMdgBwAFGQVs9W/lztV3sr1sO5tKN5Hhzkhzi2VWWAv97dD+KnScgY7448mnIDaqghILw+kfO1Px5y+BwBZYc3tq98f8CsgNgEfda+darL+f0PnziQlIRqptZ4l2Ji2pYAzeJUvwVVdT8O53O6FthRPevEuWYDz6532+afvyVy7bRVVEZDr0E19kAese6uZY67FE98njbccZijp//a3Kq+INS9+Q6D65omAFLqMxSgvWcGjrOBMPbq8mPX8tdfp+44LCZWPD3MgBWlctjWwo5ExGMjq0nTtHpKkp5ViP34+vupq8t741ZVISb1UVrgz9QWYhmY9dVEVkcVCgE1kgrLU0XGpIrP12tOUor3S9AoDHeNhQsoF7192bCHClWaVpbrFcsTGhLana1n5m/NBWvBIqdziPJaugeJWz3eODxzZD94Wx1ymonLt7ukbZaJRwY+O4oS3c0JAyE6O7oABfdTU51+90AttwaFu2HPccTSYiV9/K738v3U0QkUVKgU4kzQ6cOcC+w/to6msikBNgz/Y97Fq5i3AszEsdLyWqb0dajtA20AZAnjePmrIafmPFb7CtbBubSzeT5clK853IlFgL/R2jKmxTCG019yaFtpVQuPzyXSJv/awWyp6G5HXCJhvbZK0l0to6ajISZ8228Lnz2KRqjMnOxle9nMxNG8nf9Q5nYpLqarzLl+MpKpqL2xIRkSTfP3KRP/vJS7zeNcCSwix+9/Z1vHvb0nQ3a1o0KYpIGh04c4C9z+xlMDoy7bXHeFiWt4zG/kYG4gsrL8lZwrZyZ+HurWVbWV24GrfLna5my+WMG9ri1bbxQltB1UhQK151ZaHtcqYyy6WkaNz7Obq+/W0K77uPikc/S7SrKxHYhpLCW/jsOWL9I5PJGK8X7/Jlian+E5ORVFfj8fs1GYmIyDwQjVmeONTAZ586zmB4pLdEltfNF+/aMm9C3ZVMiqJAJ5JGt+2/jca+xjHbPS4P9669NxHiynPK09A6mdRkoa3jDAxeJrQNV9tmI7TJrLDW0vfr57jwgQ9AJALG4MrNJdbbO3KQy4W3snLsDJLVy/FWVGDc+kOLiKTHQqg4WWuJxCxDkRhD4ShDkRihSMx5HYnGtyc9j0Tjr53nI8eOvH+841LOO+q4cHTi7LO0MIunf+8tc/iJTEyzXIosACfbT44b5gCisSifuv5Tc9wiGSMR2oara1MIbcUrYcs9o0LbMvBoAov5KNzSQv+zz3Lp6afpe/ZZoq1tKfs9ZWUUfvjDidDmq6zE+BTARWR++f6Ri3zquy8wEI4CcLFrgE999wWAlFBnrU2Em9CEIWpsCBoJRxOHreH9oejE+4YiUWIzrCUZA5keNxleFxkeFz6PiwyPmwyPK/7lJifHk3ie4XHFj3Unjv8/P3153HO/3jUw7vb5ToFOZI41Xmrkr478FT848wMMBsvYn2yBnEAaWnaNGh3aRlfbJg1tSV0kFdoWhFh/P/11dfQ9/Qx9zzzD0MvOP+ruoiKytm3j0i9+4VTnAKwl3NBAwbveqXXCRCTtQpEYXf0hOvpDdPSF6OoP09EXorMvxN/84tVEmBs2EI7yyceP8YcHTqVUrWbK6zb43C4yvKkhajhgZXndFGZ5x4SoiQJWyvP4eZzzjwpq8et5XGbGXdi/U9fAxXHC25LChTkfgQKdyBzpDfXy9y/8Pf908p8AeN/m91GZV8mfPP8nKWPoMt2Z7Nm+J13NXJyshYHOUWPZJgttlU5QSw5txSuhaLlC2wJjYzEGT56i7+mn6XvmGQYOH8aGwxifj6zrtuO/413k3nQTGevX0/T5P3D+9Dvq/VonTERmWzgao7M/RGdfOP7oBLXOvhAdfeFEcBve3tUXpncocsXXiVrL2zaWjxOcRgeyyQPW8HOfx4XbtfDHA//u7etSKprgjKH73dvXpbFV06dAJ3KVhWNhHn/pcf722N/SOdTJu1a+i49u+ygVuRUAZHmyxp3lUiYw2SQf/R3jTPf/6uShbfPuken+FdoWhfDFi1x6xqnA9T/7a6JdXQBkrFtH0YMPknPjjWRftx1XVupfYrVOmIhMRyQao7M/HsL6QnT2O6FsTFBLOqZ3cOJwluNzU5TjoyjbR1GOjxWlOSmvi7N9FOV4KY5vK8z28pY///m4FaelhVl88a4tV/P2F6ThbqjzfczhVGlSFJGrxFrLf5z/Dx47/Bjnes5xfb0bAbIAACAASURBVOB6PhH8BBtLNqa7aQtX/ePw1McgkvSPlnE74WywGwa7kg42UFiVOpZtuNqm0LaoRC9dov+55xLdKENnzwLOotw5N91Ezk03knPDDXhKtTajiEwuEo3RPRBOhDKna2Nq9ayzPzQS1vpC9EwSzrJ97ngQ81KU7UuEMOe5NxHQCuP7CrO9ZHqvfHKl0WPoYP7N2ihXRpOiiKTZsdZj/EXdX3Ck5QirClbxpVu/xM1Lb9a05VfCWrjUDE3Hoakemo/DySchNuofThuFS02w9QGFtmuEjUQYqH+BvngVbuDYMYhGMVlZZO/cQdF77yPnxhvxrV6t/+dEFrCZztoYjVm6B8KJqlnnqOpZIqz1heiMj0frHghPeL5MryteHXPCV2VRNsXZ3sTr4aCWXD2bTjibjsVWcZIrowqdyCy60HuBfYf38ZOzP6Eks4RHtj3Cu1e/G49LfzuZVDQMbS87oa2p3glxzcehr3XkmIJl0H1+ghMY2Pv/s3ff8VFV6R/HP2cmk5nJpJOQQAIEBOkxQOiCiAoqimXta9+1riu2ddFdkXVVsFdQ+VnWXVdRURHsu5ZVkBYg9A4B0gNppEwy5fz+uJOe0JIwSXjeL3nNzL137pybOzHznXPucwqbWCfaO601rr17a4ZRLl+Bt6QElMI2aBCOMWNwjBmDfUgSJqlAKUSH0FiPk81i4t5zTiW5R4QRymoNZ2xsmGNRuYumPuYGBpjo5AhstPesqqes9uOIoEDsgTItiThxpIdOiBOsqKKIN9a/wQdbP8BisnDHaXdw48AbCbIE+btpbU95IeRsguwNkLPBuM3dCp4KY705EDr3hz6TIXYwxA6CmIFgj4AXBkHR/ob7DIs/sccgWp2nsJDS5cuNYZRLl+LKzATAEhdH6Hnn4Rg7hqCRIwmIiPBzS4UQLa2o3MXfv9jcoGqj0+Vl1ldbG2wfaDYZocsRSESQhf5dQ6t70iLqBzPfMrvFLD34osNoVqBTSp0LvASYgTe11rOb2O4y4GNguNZaut9Eh1HhqeCDLR8wb8M8Sl2lXNL7Eu5MupPOQZ393TT/0xoK9xqBLXtjTYArrNXLFhRlhLaRt0JsIsQMgqg+YLY0vs+zZsDiu8FV6xo6i91YLto1b2Ul5WtTjWGUS5fi3LQJtMYUHEzQqJFE/v53BI8di6V7d/kQJkQHorUmvaCclL35pKQVkJJWwPbcQ032rAG8e/MI33VnRlgLCpRwJk5uxx3olFJmYA5wDpAOrFJKLdJab663XQhwN7CiOQ0Voi3xai/f7PmGl9e+TEZJBqfHnc59w+6jT0QffzfNP1zlkLvFN2RyQ82QyYpiY70yQafeEJcMw27y9bwNhuCYBmXiD6uqmmVTVS5Fu6G1pnLnTmNC719/pWxVCrq8HMxm7KedRtQf/oBj7BjsgwejAmQwiRAdhdvjZUvWoZoAtzefnGJjhEawNYAh3cOZktiFfy5L40BJZYPnx4XbOeNUmRdSiNqa81dyBLBTa70bQCk1H7gI2Fxvu78DTwMPNOO1hGgzUrJTeC7lOTYe3Ei/yH7MO2ceo7uO9nezTpyS3LrXuWVvMK5/076hMYHBxhDJxCuMHrfYRGMIZWALDT9NvEICXDvlzsujdNkyYxjlsmW4c3MBCExIIPySS3CcPpagESMwBwf7uaVCiJZyyOli7b5CUvYWsHpvPmv3FVJWafy9iAu3M7JnJ5ITIkjuEUnf2JDqOc66RwZ1qHnChGhNzQl0cUDti1nSgZG1N1BKDQG6aa2/UEo1GeiUUrcCtwJ07969GU0SovXsKdrDC6tf4Mf9PxITFMMTpz/BBb0uwKRM/m5a6/C44eDOuoVKsjdAaW7NNmHdjNDWf6rvWrdBENETTB30ZyKOibe8nLKU1dXVKCu2bQPAHB5O0OhRBI8di2PMGCxdu/q5pUKIlpJZWE7K3gJS0oweuK3ZxXg1mBT0iw3l8mHxDEuIJLlHBF3D7U3uR6o2CnH0mhPoGhsnVT3iWSllAl4AbjzSjrTW84B5YFS5bEabhGhxB8sP8tq611iwfQG2ABvThk7j2v7XYguw+btpLcdZ3Eihki3gdhrrTRbo3A/6nOPrdRts9MIFRfq33aJN0V4vzi1baqYTWL0GXVmJsliwDxtG9H334RgzBtuA/igJ/UK0ex6vZlt2reGTaflkFhl/N4ICzQzpHs5dE/swPCGCpG7hhNiauD66CRcPiZMAJ8RRaE6gSwe61XocD2TWehwCDAJ+8l2oGgssUkpNlcIooj0od5fz3ub3eGvjWzjdTi4/9XJuP+12Otk7+btpx09ro0pkdaES3/xuBWk129gjjcA2/Pe+4DYIok6FACkHLxpyZWX5CpkYwyg9BQUAWE89lYhrrjGqUSYnY7I3/U28EKJ9KKt0k+obPrkqLZ/UfYUcqjDmBo0JtZKcEMktPYzhk/27hBBgli9uhDgRmhPoVgF9lFI9gQzgKuCaqpVa6yIgquqxUuon4AEJc6Kt83g9LN69mFfWvkJuWS4Tu03knmH30DOsp7+bdmxcTsjb6ut12+i75m0DOIt8GyhjIu4uSTDkuppCJSFdjq1QiTipeEpKKVu5sroXrnL3bgDM0VEEjx+HY8wYgkaPxtJZKr0K0d7lFDurC5es3lvApsxiPF6NUtA3JoSpSV0ZnhDJsB4RxEfYpdKkEH5y3IFOa+1WSt0FfIsxbcHbWutNSqnHgBSt9aKWaqQQJ8qvmb/yfMrzbCvYxqBOg3h6/NMMixnm72YdWemBute55WyEvG01hUosDmOI5KDf+HrdBkPMAAh0+Lfdos3TbjfOjRurJ/UuT10HbjfKZiNo+HDCL78cx5gxWE/t0yE+zC1cmyHX7IiTkter2ZFbYoS3tAJW7c1nf74xRYzNYuK0+HDuOOMUhiVEMLR7BGH2Yxs+KYRoPUofbqIPP0hOTtYpKdKJJ06s7QXbeX718yzNWEpccBzThk5jcsLktlfwxOuBg7tqrnOrCnAl2TXbhMbVXOcW66syKYVKxDGo3Levej640uUr8B46BEphGzAAx5gxxnQCQ4diCuxYw3AXrs1otKrerEsHS6gTHY7T5WHd/sLqAiar9xZQ7DSGT0YFW0nuEWFUn0yIZECXUAID5G+IECeSUmq11jr5aLaVyX3ESS23LJc5qXNYuHMhDouDB5If4Op+VxNoPoEfVNd/1Pi8ahWHIGdzzXVu2RuMx27fpNqmAIjuB6ecWSvADZZCJeKYeYqKKF2+wghwv/6KKz0dgICuXQiZPIngsWMJGjWKgIgIP7e0dT3z7dY6YQ6g3OVh9tdbOHtADA6ZvFi0YwdKKkhJM6YOWJVWwKbMIlwe40v93p2DmZLYhWE9jOqTPToFyXtdiHZEeujESanUVco7G9/hn5v/icvr4pp+13Br4q2EWcNObEPWfwSL7zYm5q6izEYoK82rWWaPqBvaYgZBdF8IsJ7Y9op2yZWbS8Z99xP/wvMEREejKyspX7fON6n3MpwbN4LXi8nhIGjkSBxjx+AYM4bAhIQO96FOa01BmYs9B0rYc6DMd1vKngNlbMkqPuxzTcqY+DjEZiHEFuD7V/d+sDWA0DrLjVtjuYVgW0D1PFtCtBatNbvySqvD2+q9Bew5UApAYICJ0+LDGNYjkuG+4ZMRjo7V2y5ERyA9dEI0we1189nOz5izdg4HnQc5N+Fc7h56N91Cuh35yS3F4zJ62/avhO9n1g1zYFz3VlECZ/61ZthkaJwUKhHH7cDc1yhfvZr0afdgDgmhdNUqdFkZmM3YBw8m6o47jGGUgwejLB3juphDThdpB8rYc7CUPXmlpB0sZfeBUvbklVQPKwMwmxTdI4NI6BTEvnwzpRWeBvsKt1u4Y8IpHHK6OeR0cajCXX0/p9jJzlzfcqcbt/fIX5I6As01Qa9W6KsOgtYA37qasBhaKyAGWwNk+Juoo8LtYUN6kW/4pNELV1DmAiAiyEJyQiRXDe9GckIEg+LCsAaY/dxiIURLkkAnTgpaa35O/5nnVz/P7qLdDO08lJcnvkxidGLrv3hZPqSnwP7lRojLWA2ussM/x+2EM/7U+m0THYbn0CFcmZm4MjJwZVTdZlC5dy8V27cDUL5mDQHxcYRffJFRjXLkSMwhIX5u+fFzujzsyy9jd14pew6UknbAuN1zsJS8QxV1to0Lt5MQFcTUpK4kdHLQK9pBz6hg4iPsWHyl1Zu6hm7m1IFHdQ2d1poKt5diX7irCn0lvvv1lx9yuimpcFNUVkl6fhnFvuUVbu8RX8saYCLEZvGFwJqgV7/XsKpXsLHl1gBTs3tgpYiMfxSUVrJ6r1G4ZHVaAesziqj0vW96RTk4u3+MUX0yIYJeUY4O19MuhKhLAp3o8DYf3MxzKc+xMnslPUJ78OKZLzKx28TW+QOnNRzcCftXGP/2rYAD24x1ygxdEmHoDdBtBHQbCW9PNuaFqy8svuXbJtotrTXe4mIjpPlCW2X1feOxt7jucEFltWKJi8NbVmYUxPF6ISCA4HHjiZ0xw09HcuzcHi/pBeXsOWD0sFWHtgOlZBaVU/uqgahgKz2jgjizbzQJUQ56RRmhrUenIGyWI/dIVAWR4w0oSilsFjM2i5nOzcjJlW4vJRU1oa92ECypuu9bX1xreU6xszosllY27Gmsz2JWTQ8htTYcNlp/m/9ty+NvizdR7jKCREZhOQ99ugFAQl0L0lqTdrCsunDJqrR8duUZwyctZsXguDBuHJPAsB4RDOsRQVSwDMUX4mQj19CJDiurJIuX177MF7u/IMIawe2n3c7lfS/HYmrBIWWucshcWxPe9q+A8nxjnS3cCG1V4S1uaMNpAhq7hs5ihwtfNgqjiJOC1hpPYWGdnrWa3jbjvrekpM5zVFAQgXFdCejalcC4OCxxcVi6djVu4+IwR0bizstj1zmT0BU1vVXKaqX3f/9DQHT0iT7MJnm9muxiZ3VQq/qXdqCUfflldYYxhtgCfEHNQYLvtup+qK1jDBdtCR6vNnoGKxr2ClYFwdqhse56X89ihZujGEHagMWsGNo9whduTcZtQM19a9XyACP8WgNMdbe1mLD61tUsM2MLMLX7iaqPpkez0u1lU2ZRdXhbvbeAAyWVAITZLQyrqj7ZI5LE+LCj+rJCCNH+yDV04qRWXFnMmxve5N+b/41Sit8N+h2/G/w7QgJbYGjZoWzY5xs6uX8FZK0Dr3GdAp36QN/zoftII8B16nPkqQKqQltjVS5Fh6G1xnPwYIOQVll9P8u4pq0Wk8NRHc6CRoyoE9YscV0xh4cfsZf5wNzX0N66w/e010ve3Nfo8uiJ7aXTWnOwtLJBYNtzwLi+zemqaafNYiKhk4O+sSGcOyi2OrT1jHIQ6QiU4WNHwWxShAVZCAs6/pCrtaa00tNk6Hv4sw2NPs/l0WgNBWWVOF0enC4vTpeHCnfN7fEKMKlaAdCMtToY1gp+vmXWxsJiQN3trLXCprWJ/ZhaqIhN/SG9VT2aZS43XULtpOzNJyWtgNT9hdU/o+6RQYw/NZpkXwGTU6KDW6w9QoiOQ3roRIfh8rj4aPtHvL7udYoqirjwlAv545A/EuuIPb4dej2Qs6lm+OT+FVC4z1gXYIOuQ2vCW/wIcHRquYMR7Yr2enEfOFBz/Vq94ObKzEQ7nXWeYwoL84W0rlga6WUzhYY2O7jsvvgSKrZubbDc2q8fvRZ+1qx9N6XY6aoOart9xUiqAtyhWsVIAkyK7p2C6NnJF9aiHcb9aAcxITb50NoOjJ39AxmF5Q2Wx4XbWTp9YpPP83o1lR5vnbDndBv3K1wenO6qdR4qXF7fulrburxU+LZ3uj3Gc+rtp/Z2FS4vlZ7jD5GBZpMRHOuExZoexvrB0Fa/B9J3f9bXW6oLlTQmwKQY2DW0uvrksB4RdA61HXe7hRDtm/TQiZOK1pr/7vsvL65+kX2H9jEydiT3J99P/079j21HziJf8RJfeEtPgUrfMLfgWCO8jbwduo0yqk8GSJnnk4X2eHDn5TUcClk1RDIzE+2q+0HNHB6OJS4Oa+/eBI8fX6d3zdK16wkpRtJaoc3p8hhBLa+0uopkVU9b1dAwMAqzxoXb6Rnl4JIhcST4AluvKAdx4fZ2P3zuZPenyX0bLSLzp8l9D/s8k0lhM5lP6FBBj1fXhEBXrYDorgmNdYJhnWBZ07NYUS80llW6yS+t2U/t1ziaiqdV3r9lJEndwgkKlI9lQohjJ//nEO1aam4qz6U8R2peKr3DezPnrDmMixt35J4NraEgrVbv20qjNw4NygQxA+G0q4zw1m0EhHeXaQM6MO12487JqVVopF5PW3Y21A9snToZga1/f4LPPqu6dy3Qd2tyOJp4tfbB5fGyP7+s0evaMovq9jZ2DrGS4KusV/u6tu6RR1eMRLRPzS0icyKZTYqgwACCTuD3cG6Pt05v46VzfyW3XvVVML70GHNK1IlrmBCiw5Ehl6Jd2l+8nxfXvMh3e78jyh7FXUl3cVHviwgwNfEdhbvCuN5t/4qaa+BKc4111lCIH15TwCQ+Gaztt5T7yaD+RNlHol0uXNnZTRcdyckBT92qgAHR0Q2uW6u+36ULJru9tQ6vRR2uCIPXq8ksKq8OarWrSO4vKMdTq4chzG6hp69yZP1iJMFW+W5QiCNpalqMWZcObpMhWAjhX8cy5FICnWhXCp2FvLH+DeZvm4/FZOGmgTdxw8AbCLIE1d2wJK9u71vmWvD4vhmN6GmEt6rr36L7gUl6EdqTrJl/o/DDDwm/6iq6PDoDb2Ul7qyseuX8a3rZ3Dk5Rtn+KkoREBNTK7B1rbnf1bhvsrb/0t8L12Yw/dP1dQqOBJgU/buEUOH2svdgWZ0CFXaLuU4BkqrA1ivKQYRDhhgL0Vwyb58Q4mhJoBMdToWngve3vM//rf8/St2lXNL7Ev6Q9Aeig6KND+p5W2vC2/7lkL/beKI5ELok1YS3biMhuLN/D0YcN11ZyaH//Y+Me+41etSUwhwZiSc/nzoTkplMBMTGENi1kd61rl2xxMaiAtt3QNFaU+x0k1vsJLvYSXaRk5xiJznFFWQXG/c3ZhQ1WnY+wKSY0LczvaIdxnVtUcZE251DrFJBUgghhGgDpCiK6DC82svXe77m5TUvk1maybi4cdyXeDu9Swpg1Tu+ELcKKoqMJwRFQfdRMOxG4/q3LqeBRaqEtVfa66Vi61ZKly2jdNlyylavRpfXrapnDg0l4uqr687DFtMZZWm/c5JVur3kHjJCWXZRhS+o1QS33EMVZBc56wzdqhIeZCEmxEZMmK3JOcQ8Xs2bNxzV3wghhBBCtHES6ESbtSp7Fc+lPMemg5voZ4/lb2HDGbVzAyw9A7QXUNC5Pwy6tOb6t8heUrykHdNa49q3rybArViBp7AQgMBTTiH0vPMoWry4pkCJ1rgyM4m48oo2NVF2U7TWFJS5avWmOat703KKK6qXHyytbPDcwAATMaFWYkNtDOwaysR+nYkNNYJbTIiV2DAbMaG2OkVImior3zW8fVz/J4QQQogjk0An2haPi927vuGFDfP4qSSNGI/mifx8LijZh8myyShYMu4BYwhlXDLYw/3dYtFM7rw8SpevMELc8mW4M7MACIiNJXjCBByjRxE0ajSWmM5kzfxbg+f7a6Ls+pwuD9lFtQOar3ftkJMc3/Lc4opG58OKCg4kJtRGlzAbp3ULJzbURmyYlc6hNuN+qI3wIMsxD4c83rLyQgghhGg/JNAJ/yrL9133toID+5fxWtlOPnHYsGnNNKeJa6OGYxs0xuh96zwQzPKWbe88hw5RtmqV0QO3fBkVO3YCxkTbjhEjCPr973GMHk1gQkKDAFOemtpg+gBcLsrXrm299no1B0uqrkvz3RY17F0rKm84YXBQoNnoRQu1kdwjgpgwW/XjmFAbsWE2ooOtBAa0znxs7amsvBBCCCGOjxRFES1v/Ufw/WNQlA5h8XDWDEi8wihacWCH77o339QBB7ZTrhT/CgvjrfAwKhVc3nkEtyffR2T0AH8fiWgB3spKytemUrrsV8qWLad840bweFBWK0HDhhE0ehSOUaOxDeiPMp/YaqOHnC5yiit8vWlVvWi+a9WKK8gtNq5X89S7GM1sUkQHWxsMd4yp6lELsxITaiPYGiBFRoQQQghxzKTKpfCf9R/B4rvBVeu6HZPFuNataD+UFxjL7BF44kewKKITrxZtJLeykLO6n8U9Q+8hISzBL00XLUN7PDi3bK0OcGVr1qCdTjCbsQ8aVB3g7EOSjmtqgKMp++3yeMk7VL83rSa4VQ2DLK1sWFQk1BbQIKDFhFqre9RiQ210CrZiNklQE0IIIUTrkEAn/OeFQUZwq88UAKddXT11wK+VeTy3+nm2F2xncNRgHkh+gKExQ098e0Wzaa2pTEujbPlySn9dRunKlXiLjKqj1j69CRo12rgObvhwzCHNm7C9qXnVhveMwBEY4KsCWcHB0grq/68t0Gyic1Uwqx72WNO7Fhtqo3OolaBAGdYrhBBCCP86YdMWKKXOBV4CzMCbWuvZ9dbfDvwB8AAlwK1a683NeU3RxjUW5gC8HrjoVbblb+OF1c+zNHMpccFxPDP+GSYnTJZhae2MKyeXsuVGJcrS5ctxZ2cDENC1CyFnnWUEuJEjsXQ+9jn/ip0u0vPLySgsJ72gjPSCcjIKykkvLGNTZnGDoOb2albszqdvbCixoVYGx4XROaSmN62zrzJkpCNQ3mdCCCGE6HCOO9AppczAHOAcIB1YpZRaVC+wva+1ft23/VTgeeDcZrRXtFVeL/z4RJOrc8LjeXXpI3y+83NCAkN4IPkBru53NYHm9j2588nCU1xsFDL5dRmly5dTuWsXAOawMIJGjcJx+204Ro/G0r37YUOT1pqichfpBeW+f2W+4FbuC25lFDvddZ5jt5iJj7ATF2FvEOZq9gtfTxvXYscrhBBCCNFeNKeHbgSwU2u9G0ApNR+4CKgOdFrr4lrbO4C2Nb5TtAxnEXx6K2z/BnqM5cuCTbwUGkR2gJkYj4f+lW6WOSx4dn/J9QOu55bEWwizhvm71eIwvBUVlK9dWx3gnBs3gteLstsJGjaM8EsvIWjUKGz9+6NMNRUatTYqQtaEtDKjd60qsBWWU1JRN7A5As3ERwQRH2FnREIEcRH26sdx4fY6PWsyr5oQQgghRF3NCXRxQO3xdenAyPobKaX+ANwHBAITG9uRUupW4FaA7t27N6NJ4oQ7sAM+uBoK9sD5z/Jlpy7MXDoDpzZKuGcHBJAdEEBipwE8Nf4p4kPi/dxg0Rjt8eDcvNkX4JZRvmYtuqLCKGSSmEjU7bcZAe600zhYqdlXFdB+2VN3WGRBeZ05z8AoMhIXEUT3TkGM6d2JuPCawBYfYSfMfvTzq8m8akIIIYQQdTUn0DX2CaxBD5zWeg4wRyl1DfBX4IZGtpkHzAOjKEoz2iROpO3fwie/B7MFrv8cEk7npQWTqsNcbXnleRLm2hCtNZV79lQHuLKVq/AWGx3q5t59qDz/InJ7J7KzSx/2OpXR0/ZLGRmLfqDCXXdi7PAgC/ERdk6JDmb8qdG+oBZEXLgxTDLMbmmxdsu8akIIIYQQdTUn0KUD3Wo9jgcyD7P9fOC1ZryeaCu0hl+egx8eh9jBcNW/Ibw7Hq+HrNKsRp+SXZp9ghsp6nPl5FDy6zIO/ryEipUrMB08AEBJeDQ7eySxutMp/M+RQJ7FYXw1swPYsZ9OjkDiI+z0iw3h7P4x1UMh4yOCiIuwE2w9sVUhLx4SJwFOCCGEEMKnOZ/EVgF9lFI9gQzgKuCa2hsopfporXf4Hk7B+Igo2rOKEvj8Ttj8OQy6DKa+AoFBZJZk8tAvDzX5tFhH7Als5MnL7fGSVeQkvaCcrIxcnKtWYl23hs471hNVYITqokAHqdG9WZc0gdTo3rhjuhIfafSo/abq2rUIO90i7HQNt0sZfyGEEEKINuy4P6lprd1KqbuAbzGmLXhba71JKfUYkKK1XgTcpZQ6G3ABBTQy3FK0IwVp8ME1kLcFznkMxtwNSvH1nq/5+7K/48XL5adezsIdi3DpiuqnWZSVaUOn+a/dbdzRTJRdpdLtJauovFahkTLSfQVIcvOKiEzbymk520nK28GphRmY0TgDAtkb15ftw8/ClTSM0P79GdDJwSRfYLNZzCf4iIUQQgghREtp1lfvWuuvgK/qLZtR6758iu8odv8EH98I2gu//Rh6n01JZQlPrniSxbsXkxSdxKxxs0jZqZifFYCK/BplKUS7wnHmn4erKMnfR9AmLVybUafIR0ZhOX/+ZD1bs4vp0cnRoEpkziFndel+k9dD36J0xhWncVbeDrpn7yLA7UKbzbj7DsR6yXlETzidsCFJDAmU6SGEEEIIIToipZua2MlPkpOTdUpKir+bIapoDctfg+/+ClF94Kr3odMppOamMv2X6WSXZnPbabdxy+BbCDAFNFlWPsQawPVjeqC1cXmWcWs8MB7rBuuq3ppa6wbLqx5T9bhqf9XbNfEaddb7nlF7v4d7jSb2Qf221dsHDfZZs49NmUW4PE3/DppNii5hNqPQSLidU50HOCV9C9Hb1mPZuBZKSwGw9uuHY9QoY0Lv5GRMDsfxnnEhhBBCCOFnSqnVWuvko9lWLo4RTXOVwxf3wroPoN8FcMnruC125qXO5Y31b9DF0YV/nPsPkjrX9L5lNhLmAA5VuHn9f7tRgFKgUPj+q36sqh+rmhKqtZfVW29Uuq+9vOF+qFre1Gs0ss+q7ai/vN4+qPOchvuo3rcJFKYG+wCqw1yEs5jpq95j9vBrKbCFooAl0ycSWZJPxcqVlC77hrLly3Hn5QFg6dYNx/nnGwFu5EgCOnU6/vMshBBCCCHaLQl0onFFGfDhbyFzLUx4CMY/yP7SDKZ/fzvr89Yz9ZSpPDTi4WaOOQAAIABJREFUIYIDgwGjGMfcn3Y1OXN8XLidpdMbnYbwpFbVo3nN1v8w6OAert/8NSkx/Tm9eDfOK18hbe9eAMyRkThGjSJo9Cgco0cTGC9TQAghhBBCCAl0ojH7lsOH14GrDK56H933fBbvXswTy5/ArMw8M/4Zzu15bvXm+/PLuOfDVFbvLWBo93A2ZxXjdNXMVXayTfystUaXl+MtL8db7kSXlxn3y8rxlpfVrCsrZ1ZFDss27uC8vSswoZm8bxXn7luF12YncOQIwq++Csfo0Vj79EGZTP4+NCGEEEII0cZIoBN1pbwNXz0I4d3ghsUUhXXh8Z8f5Ju0bxgWM4xZp8+iS3AXwAgun67J4NFFm1DAi1cmcfGQOBauzWDeZyu58fs3eees33PbJSPa3LxhurISr9PpC1Z1Q1ZN6PKtr3pcVl7zuOq+0xfYqteVo8sbH3bamGjgwlqPvSjKkscw/J3XUJaWm5BbCCGEEEJ0TBLohMFdCV8/CKvfgd5nw2/eZFXRTh5e/EcOlB1g2tBp3DTwJswmo8R9UZmLhxdu4Mv1WYxIiOS5K06jW2QQYEz8PPLz9RTm7+Ft8wa6DLnkmJujvV50VeBqJHRpZ+0AVi9kVYewmufrsrJa68rB7T6m9iiLBRUUhMlmw2S3o4LsmOxBmENDMcXEYAqyo+x2TDZ7zX17ECZ7vcdBdkw2G8p331tSwu4Lp6IrjGkezGhCN6TgKSwkIDr6mH9uQgghhBDi5CKBTkBJLnx0PexbBmPvwTXhIeZueIO3NrxF99DuvHf+ewyMGli9+a+7DnD/R+vIO1TBnyb35fYzTsFsqi5jgis7m8JPPgGtKfz4Y8wRESizqW4vl7O8YQCr3cvldB7bMSjlC001/6pClyUszHhstzUdsux2lC+MVT+/dgBrpd6yrJdfQXu9dZZpr5e8ua/R5dEZTTxLCCGEEEIIgwS6k13GGpj/WygvgN+8RVr3ZKZ/eyObDm7iN31+w4PDHyTIYvS8Vbg9PP/ddub9spuenRx8eucYEuPD6+yubPVq0u/6I7hcxgK3m4Nz5wK1ernqhS5zWBiW2NjD92zZbQ0CmPF8Y1tltVZXtWxPylNTa35WVVwuyteu9U+DhBBCCCFEuyKB7mS2bj4suhuCO6Nv/oZPS3bx1BdXEGgO5IUJL3B2j7OrN92Ze4i7P0hlc1YxV4/oziMX9CcosObt48rKIveZZyn+6qsGL6OsVk759hsssbEn5LDak14LP/N3E4QQQgghRDsmge5k5HHDf2bA8jmQMI7CqS8xc90rfL/ve0Z2GckTY58gxhEDGIVP/rV8L098uQWHNYB51w1j0sCaYOZ1Ojn41lsc/L83QWusAwdSsX17nV4n7fVy4I15MoRQCCGEEEKIFiaB7mRTlg8f3wh7/gcjbmNZ4lT++t9bya/I54HkB7huwHWYlFEeP+9QBQ8uWMeP2/I449Ronrk8kc4hNsAIeoe+/Zacp5/GnZlFyHnnEvPAA+z/w10yhFAIIYQQQogTRALdySR7I8y/Bg5lUXnhS7zsPcC7399Br7BezDl7Dv0i+1Vv+v2WHB5csJ5DFW5mXjiAG8YkVF+j5tyyhZwnnqQsJQVrv350nT0bx4gRgAwhFEIIIYQQ4kSSQHey2LQQFt4B1lB2Xf5//Hn7e2wr2MaVfa/k/uT7sQfYASiv9PD4l5v594p99IsN4YNbR3FqTAgA7vx88l562ahcGRpK7MyZhF9+Gcps9ueRCSGEEEIIcdKSQNfReb3w4+Pwy3Po+GQ+TL6SZ1Mex2Fx8OrEVzmj2xnVm25IL2Lah2vZnVfKLeN68sDkvlgDzGiXi4IPPiDv1Tl4y8qIvO5aou68E3NYmB8PTAghhBBCCCGBriNzFsEnt8CObzl42pXMCDbz87pXGBs3lsfHPk6UPQoAj1fzxs+7eP677UQFW/n370cytrexruSXJeTMmkXl7t04xo4l5uGHsJ5yij+PSgghhBBCCOEjga6jOrADPrgaCvbwy/i7+GveEkqyS5g+YjrX9Lum+nq4jMJy7vswlRV78jl/cCxPXjKY8KBAKtPSyHnqaUp+/BFLj+7Ez51L8JkT2uVcb0IIIYQQQnRUEug6om3fwKe34DQH8sKYa3h//yL6RPThzUlv0ieiT/Vmn6dm8NeFG/F6Nc9clshlw+LxlpaS88xL5P/zX5gCA+n8pweIuO46TIGBfjwgIYQQQgghRGMk0HUkWsMvz8IPT7CtywCmR0eyM+MnrhtwHdOGTsNqtgJQ7HQxY+FGFqZmMqR7OC9emUT3CDtFn35G7gsv4DlwgLBLL6XzvfcQEB3t54MSQgghhBBCNEUCXUdRUQKf34l38+f8u+/pvODOIsxdyutnv87YuLHVm63ck8+9H6aSXezknrP7cNeZvalcv460257EuXEj9qQkYl6bi33wYD8ejBBCCCGEEOJoSKDrCPL3wPzfkpe/jb8OGM2v5fuY0G0CfxvzNyJtkQC4PF5e/O92XvtpF/ERQXx022gSbZXkTJ9O8eLFBHTuTNdnnib0ggvkOjkhhBBCCCHaCQl07d2uH2HBTfwQaOLRnn1wVh7kkVGPcPmpl1cHs915Jdz7YSrr0ou4fFg8Myb3puL9f7HrjXng8dDp9tuIuuUWTA6Hnw9GCCGEEEIIcSyaFeiUUucCLwFm4E2t9ex66+8Dfg+4gTzgZq313ua8pvDRGpbPpew/j/Bs1x58bHHTP7Q7s8fPpldYL98mmvmr9vPY4s0EBph47ZohjM3eSM4l9+PKyCDknHPo/OcHCYyP9/PBCCGEEEIIIY7HcQc6pZQZmAOcA6QDq5RSi7TWm2ttthZI1lqXKaXuAJ4GrmxOgwXgKofF97B56yf8OaEXe3UlNw26iT8m/RGL2QJAfmklf/5kPf/ZnMPY3p14KikIz3MPk7FiBdY+fej+j3dwjBrl5wMRQgghhBBCNEdzeuhGADu11rsBlFLzgYuA6kCntf6x1vbLgWub8XoCoCgd74e/5R+lu3glLo5Iexj/d/qTjOwysnqT/23P44GP11FU5mLmGXFMXrmIwuc/xBwSQsyMR4i44gpUgIy2FUIIIYQQor1rzqf6OGB/rcfpwMgmtgX4HfB1YyuUUrcCtwJ07969GU3q4PYuI3vB9fwlxMzKyAjO6XEWj45+lDBrGABOl4fZX2/lH7+m0S/azrvhmZhn/o3CkhIirrmG6Lv+gDk83M8HIYQQQgghhGgpzQl0jZVC1I1uqNS1QDJwRmPrtdbzgHkAycnJje7jpJfyNt/+NIPHOkXgslh5bORfuLj3xdWFT7ZkFTNt/lq255Tw5+hizvnxdVw7d2IbPYqYhx7Cduqpfj4AIYQQQgghREtrTqBLB7rVehwPZNbfSCl1NvAX4AytdUUzXu/k5K6k9Kt7mb3vKxZGRzA4sj+zz3iW7qFGT6bXq3l76R6e/mYbfTyFLMz6AevCJdCtG/GvvkLwWWfJNARCCCGEEEJ0UM0JdKuAPkqpnkAGcBVwTe0NlFJDgDeAc7XWuc14rZPToRzWf3QV03UWGSHB3Dr4Fm5PugOLySh8kl3k5IGP17F6SzoPF6xg5KpvUBYLUffdR+QN12OyWv18AEIIIYQQQojWdNyBTmvtVkrdBXyLMW3B21rrTUqpx4AUrfUi4BkgGPjY10u0T2s9tQXa3eF50lfx5qIbeC3IRGdrFG9PfIlhMcOq13+9IYuHP13HqJ2r+HDHN1gK8wm76CKi77sPS0xnP7ZcCCGEEEIIcaI0q9Sh1vor4Kt6y2bUun92c/Z/sspY+RoPr32RNY5AzosdzV/PfJbQwFAASirczFy0iQ3/WcrsbV/QPWcPtsREYl+fgz0pyc8tF0IIIYQQQpxIUru+LfG4+XLRzTxeuBpttTJrxENc0P/q6tWr9xbw6Dv/Y/LSBfxu/2rMUVF0nj2LsKlTUSaTHxsuhBBCCCGE8AcJdG3EoaJ9PLHwCr6klCRrJ2ZN+SfxYQkAuD1e5ny7mcy33uHv277HipdOt9xCp9tuwxzs8G/DhRBCCCGEEH4jga4NWLNlAQ8t+xs5Js0fYsfx+0mvEGAyTk3agRLmzfoHZ/84n0llB7FNOJO4h6cTKPP1CSGEEEIIcdKTQOdHLq+LN/57L/+X+RNdgXeHP8JpA68EQGvN4s+XUPbCs1yXs52K+B50e+UpgseO9WubhRBCCCGEEG2HBDo/2V+0l+lfXc/6ynwu0kE8dPF8HJG9AMjPyuO7Bx9nUMp/qQy0YbvvQfrdfB0qQE6XEEIIIYQQooYkhBNMa83nW+cza+VszB43z4QO4tyL/wkBVrTbzeq57+B96w0GVZSRPf48xs/6C4GdIv3dbCGEEEIIIUQbJIHuBCqqKOKx/z3Id1m/kuysYNag24kdcy8oReGvy9j6l5mEZe1je5dT6fW3Rzh7fLK/myyEEEIIIYRowyTQnSArs1by8E/3cbCikHtKXNw45S3MPcdRmZ7OrseehJ9/pDwogtTf3s/1D95IkFVOjRBCCCGEEOLwJDW0MpfHxatrX+WdTW/To9LFezqSgdd+iDewE7kvvEjeW29TqRWLTpvC2Ol3c/sQqV4phBBCCCGEODoS6FrRnqI9/Pl/f2JLwTYuKz7En7qcif3CVyn67geyn3kWb24uP8UPZeuF1zHj5jOJDrH6u8lCCCGEEEKIdkQCXSvQWrNgxwKeXjEbm8fFi3kHOGvsw5SHTGDvDb+nPDWVXZHdmTfhj1x2w/m8PKoHSil/N1sIIYQQQgjRzkiga2EFzgIe/fVRftz/I6Mr3DxeWE7kmXPJ/CyFos+upNwRymtDriBz5ERevHoofWJC/N1kIYQQQgghRDslga4F/ZrxK39Z+heKnPn8Kb+Qa8xdKLLfzK7bn8BTUcF/B53N6z3O4LqJA3h10qlYA8z+brLooFwuF+np6TidTn83RQghxEnGZrMRHx+PxWLxd1OEOClIoGsBFZ4KXlrzEv/a/C9OMdl5bX8Gce6RpC114dr3NgcGD+fhLmfh7hLPm1ecxphTovzdZNHBpaenExISQkJCggznFUIIccJorTl48CDp6en07NnT380R4qQgga6Zdhbs5M+//JntBdu52mPjrnW7KUxLIn3zbkw9EvjXxffyPnFMSezCkxcPJixIvq0Src/pdEqYE0IIccIppejUqRN5eXn+booQJw0JdMdJa80HWz/g+dXP4zAFMjenglOXlZGxPQZTUDG5193BNGdv3CYzz00dyKVD4+TDtTih5P0mhBDCH+TvjxAnlgS643Cg/AAzls7gl4xfGBfUg4cWr6N8fTD5FQEEXXopc3qezUc7SxjWI5wXr0yiW2SQv5sshBBCCCGE6IAk0B3Bl7u/5KU1L5Fdmk2sI5ZJPSaxePdiSipLeDw3jsGfbKWkMJigoUnk3jSN368uI3t3Kfedcyp3TjiFALPJ34cghBBCiDYuLS2NCy64gI0bN7b4vn/66SeeffZZvvjiCxYtWsTmzZuZPn36ce0rISGBkJAQzGYzAQEBpKSktHBrhRDHStLGYXy5+0tm/jqTrNIsNJqs0ize3fwuMUWafy/wcupbe/GoMGKeeYb5183gih8OEmBWLLh9NHef1UfCnGg3Fq7NYOzsH+g5/UvGzv6BhWszWv01zz//fAoLCyksLGTu3LnVy3/66ScuuOCCVn/9YzVz5kzi4uJISkoiKSmJr776yj8NWf8RvDAIZoYbt+s/avWXbG/n6uOPP2bgwIGYTKYGHzZnzZpF79696du3L99++61f2vfl7i+ZtGASie8mMmnBJL7c/WWrv2Z7O4eH+31rC+cQwJWbS9q11+FuZ9eKTZ069bjDXJUff/yR1NRUCXNCtBGSOA7jpTUv4fQ4CS/RzHzPTXShl8t/9vCXl/NgZzlRV56F+uhbbkgL57X/7eaKYd346u5xDOke4e+mC3HUFq7N4KFPN5BRWI4GMgrLeejTDa0e6r766ivCw8MbfMA8kdxu9zFtf++995Kamkpqairnn39+K7XqMNZ/BIvvhqL9gDZuF9/d6qGuvZ2rQYMG8emnnzJ+/Pg6yzdv3sz8+fPZtGkT33zzDXfeeScej6elm3pYjX1ROPPXma0e6trbOYTGf9/awjmscmDua5SvXk3e3NdabJ9ut5sbbriBxMRELrvsMsrKynjssccYPnw4gwYN4tZbb0VrDcDLL7/MgAEDSExM5KqrrgKgtLSUm2++meHDhzNkyBA+//zzBq/xj3/8g7vuuguAG2+8kbvvvpsxY8bQq1cvFixYUL3dM888w/Dhw0lMTOTRRx9tsWMUQrS8Zg25VEqdC7wEmIE3tdaz660fD7wIJAJXaa0XNNxL25VdmgXAb5Z46L8fnn3Ti90FS/srrn90Dh85T+HxeauwWcy8fu1Qzh3Uxc8tFqKhvy3exObM4ibXr91XSKXHW2dZucvDgwvW88HKfY0+Z0DXUB69cOBhX/fpp5/GZrNx9913c++997Ju3Tp++OEHvv/+e9555x2WLFlCSkoK06dPZ9euXSQlJXHOOecwZcoUSkpKuOyyy9i4cSPDhg3jvffea/Ii+4SEBG644QYWL16My+Xi448/pl+/fuTn53PzzTeze/dugoKCmDdvHomJicycOZPMzEzS0tKIiopi0qRJLFy4EI/Hw8aNG7n//vuprKzkX//6F1arla+++orIyMgj/JRbyNfTIXtD0+vTV4Gnou4yVzl8fhesfrfx58QOhvNmN77Op6Odq/79+zf6+p9//jlXXXUVVquVnj170rt3b1auXMno0aMP+/M5Fk+tfIqt+VubXL8+bz2V3so6y5weJzOWzmDB9sb/RPaL7MefR/z5sK/b0c5hU07EOcx+8kkqtjR9DgF0ZSXl69eD1hTOn0/Fli2ow8y5Zu3fj9iHHz7ia2/bto233nqLsWPHcvPNNzN37lzuuusuZsyYAcB1113HF198wYUXXsjs2bPZs2cPVquVwsJCAJ544gkmTpzI22+/TWFhISNGjODss88+7GtmZWWxZMkStm7dytSpU7nsssv47rvv2LFjBytXrkRrzdSpU/n5558ZP348SikmTZqEUorbbruNW2+99YjHJYRoXcfdQ6eUMgNzgPOAAcDVSqkB9TbbB9wIvH+8r+NPsR5NeIlm4jpQgNUFT//GxEcXmrhzXQh/XbiR4QmRfHvPeAlzot2qH+aOtPxojR8/nl9++QWAlJQUSkpKcLlcLFmyhHHjxlVvN3v2bE455RRSU1N55plnAFi7di0vvvgimzdvZvfu3SxduvSwrxUVFcWaNWu44447ePbZZwF49NFHGTJkCOvXr+fJJ5/k+uuvr95+9erVfP7557z/vvG/po0bN/L++++zcuVK/vKXvxAUFMTatWsZPXo0//znP6uf9+qrr5KYmMjNN99MQUFBs34+x6V+mDvS8qPUEc9VYzIyMujWrVv14/j4eDIyWn94cW31w9yRlh+tjngOG/t9awvnEKAyM7Pu4xZqQ7du3Rg7diwA1157LUuWLOHHH39k5MiRDB48mB9++IFNmzYBkJiYyG9/+1vee+89AgKM7+e/++47Zs+eTVJSEhMmTMDpdLJvX+NfzFW5+OKLMZlMDBgwgJycnOr9fPfddwwZMoShQ4eydetWduzYAcDSpUtZs2YNX3/9NXPmzOHnn39ukWMXQhy/5vTQjQB2aq13Ayil5gMXAZurNtBap/nWNe+ToZ9MO5jPntVhRpoDPGYYutvLpeFF3F94gEcuGMBNYxIwmaQ8r2i7jtSTNnb2D2QUljdYHhdu58Pbjv9b72HDhrF69WoOHTqE1Wpl6NChpKSk8Msvv/Dyyy8za9asJp87YsQI4uPjAUhKSiItLY3TTz+9ye0vvfTS6tf89NNPAViyZAmffPIJABMnTuTgwYMUFRUBxjUkdru9+vlnnnkmISEhhISEEBYWxoUXXgjA4MGDWb9+PQB33HEHjzzyCEopHnnkEe6//37efvvt4/3xNO4IPWm8MMg33LKesG5w0/EP2eto56opVUPVamvp8upH6kmbtGASWb7RH7V1cXThnXPfOe7X7WjnsKnftxNxDo/Uk+bKzWXXOZOgqi1a4y0uJu755wiIjm7Wa9c/FqUUd955JykpKXTr1o2ZM2fidDoB+PLLL/n5559ZtGgRf//739m0aRNaaz755BP69u1bZz9VQa0xVqu1+n7Vz1drzUMPPcRtt93WYPuuXbsC0LlzZy655BJWrlzZYHizEOLEas41dHFA7U8W6b5lx0wpdatSKkUpldKWJqIcVxLKmRs0Ft/wfIsHJq7XDD1g5/O7xvK703tKmBPt3p8m98VuMddZZreY+dPkvk084+hYLBYSEhJ45513GDNmDOPGjePHH39k165dTQ6Jq1L7A4bZbD7itTdV29fe9nAf/BwOR5OvZzKZqh+bTKbq/cXExGA2mzGZTNxyyy2sXLnysG1qFWfNAIu97jKL3VjeDB3tXDUlPj6e/ftr/mylp6dXfzg9UaYNnYbNbKuzzGa2MW3otGbtt6Odw6Z+39rCOTww9zW0t+731NrrbZFr6fbt28eyZcsA+OCDD6qDdVRUFCUlJdXXuHm9Xvbv38+ZZ57J008/TWFhISUlJUyePJlXXnml+nysXbv2uNoxefJk3n77bUpKSgCjZzQ3N5fS0lIOHToEGNfrfffddwwaNKhZxyyEaL7mBLrGkkzD/6MfBa31PK11stY6ObqZ3261pJ/W9MZU74hMGlZv7k//LqH+aZQQLeziIXHMunQwceF2FEbP3KxLB3PxkOP6fqaO8ePH8+yzzzJ+/HjGjRvH66+/TlJSUp1voUNCQqo/ILSk8ePH8+9//xswKvlFRUURGnr8v7dZWTW9Kp999pl/PsQkXgEXvmz0yKGM2wtfNpY3U0c6V02ZOnUq8+fPp6Kigj179rBjxw5GjBjR4q9zOFN6TWHmmJl0cXRBoeji6MLMMTOZ0mtKs/fdkc5hU79vbeEclqemgstVd6HLRflxhqfa+vfvz7vvvktiYiL5+fnccccd3HLLLQwePJiLL76Y4cOHA+DxeLj22msZPHgwQ4YM4d577yU8PJxHHnkEl8tFYmIigwYN4pFHHjmudkyaNIlrrrmG0aNHM3jwYC677DIOHTpETk4Op59+OqeddhojRoxgypQpnHvuuc0+biFE8zRnyGU60K3W43ggs4lt2yVTTjl46+VWrzKWC9GBXDwkrkUCXH3jxo3jiSeeYPTo0TgcDmw2W53reQA6derE2LFjGTRoEOeddx5TpjT/gy0YZc9vuukmEhMTCQoK4t13mygacpQefPBBUlNTUUqRkJDAG2+80SLtPGaJV7RIgKuvI52rzz77jD/+8Y/k5eUxZcoUkpKS+Pbbbxk4cCBXXHEFAwYMICAggDlz5mA2m4+8wxY2pdeUFglw9XWkc9jU71tbOIe9Fn7WKvtNSEhg8+bNDZY//vjjPP744w2WL1mypMEyu93e6P+bJkyYwIQJEwCjsuWNN94IGBUva6vqkQOYNm0a06Y17Dlet27d4Q5DCOEHqrFhEkf1RKUCgO3AWUAGsAq4Rmu9qZFt/wF8cTRVLpOTk3VbmdfkcNcWLZ0+0Q8tEuLobNmy5YjDrIQQQojWIn+HhGgepdRqrXXy0Wx73EMutdZu4C7gW2AL8JHWepNS6jGl1FRfQ4YrpdKBy4E3lFINwl5b1lrXFgkhhBBCCCFES2jWPHRa66+Ar+otm1Hr/iqMoZjtUtUQtGe+3UZmYTldw+38aXLfVhmaJoQ4vEsuuYQ9e/bUWfbUU08xefJkP7VINEXOVfsn51AIIdqP4x5y2Vra0pBLIdqrLVu20K9fvxYv5y2EEEIcidaarVu3ypBLIZrhhAy5FEK0XTabjYMHDzZaSlwIIYRoLVprDh48iM1mO/LGQogW0awhl0KItik+Pp709HTa0ryOQgghTg42m616snohROuTQCdEB2SxWOjZs6e/myGEEEIIIVqZDLkUQgghhBBCiHZKAp0QQgghhBBCtFMS6IQQQgghhBCinWpz0xYopfKAvf5uRyOigAP+boTo0OQ9JlqTvL9Ea5L3l2hN8v4Sramtvr96aK2jj2bDNhfo2iqlVMrRzgUhxPGQ95hoTfL+Eq1J3l+iNcn7S7SmjvD+kiGXQgghhBBCCNFOSaATQgghhBBCiHZKAt3Rm+fvBogOT95jojXJ+0u0Jnl/idYk7y/Rmtr9+0uuoRNCCCGEEEKIdkp66IQQQgghhBCinZJAJ4QQQgghhBDtlAS6o6CUOlcptU0ptVMpNd3f7REdh1Kqm1LqR6XUFqXUJqXUNH+3SXQ8SimzUmqtUuoLf7dFdDxKqXCl1AKl1Fbf/8tG+7tNouNQSt3r+/u4USn1gVLK5u82ifZLKfW2UipXKbWx1rJIpdR/lFI7fLcR/mzj8ZBAdwRKKTMwBzgPGABcrZQa4N9WiQ7EDdyvte4PjAL+IO8v0QqmAVv83QjRYb0EfKO17gechrzXRAtRSsUBdwPJWutBgBm4yr+tEu3cP4Bz6y2bDnyvte4DfO973K5IoDuyEcBOrfVurXUlMB+4yM9tEh2E1jpLa73Gd/8QxgehOP+2SnQkSql4YArwpr/bIjoepVQoMB54C0BrXam1LvRvq0QHEwDYlVIBQBCQ6ef2iHZMa/0zkF9v8UXAu7777wIXn9BGtQAJdEcWB+yv9Tgd+cAtWoFSKgEYAqzwb0tEB/Mi8CDg9XdDRIfUC8gD3vEN631TKeXwd6NEx6C1zgCeBfYBWUCR1vo7/7ZKdEAxWussML5oBzr7uT3HTALdkalGlslcD6JFKaWCgU+Ae7TWxf5uj+gYlFIXALla69X+bovosAKAocBrWushQCntcLiSaJt81zJdBPQEugIOpdS1/m2VEG2PBLqh4n0FAAAgAElEQVQjSwe61Xocj3T3ixaklLJghLl/a60/9Xd7RIcyFpiqlErDGC4+USn1nn+bJDqYdCBda101smABRsAToiWcDezRWudprV3Ap8AYP7dJdDw5SqkuAL7bXD+355hJoDuyVUAfpVRPpVQgxsW4i/zcJtFBKKUUxrUnW7TWz/u7PaJj0Vo/pLWO11onYPy/6wettXy7LVqM1job2K+U6utbdBaw2Y9NEh3LPmCUUirI9/fyLKTojmh5i4AbfPdvAD73Y1uOS4C/G9DWaa3dSqm7gG8xqiu9rbXe5OdmiY5jLHAdsEEplepb9rDW+is/tkkIIY7FH4F/+7703A3c5Of2iA5Ca71CKbUAWINRFXotMM+/rRLtmVLqA2ACEKWUSgceBWYDHymlfofxJcLl/mvh8VFay+VgQgghhBBCCNEeyZBLIYQQQgghhGinJNAJIYQQQgghRDslgU4IIYQQQggh2ikJdEIIIYQQQgjRTkmgE0IIIYQQQoh2SgKdEEKIDksp5VFKpdb6N70F952glNrYUvsTQgghjofMQyeEEKIjK9daJ/m7EUIIIURrkR46IYQQJx2lVJpS6iml1Erfv96+5T2UUt8rpdb7brv7lscopT5TSq3z/Rvz/+zdd3yU15Xw8d+dpt4lmgpNFAGuNGPTDDZuELfYMeAGqZtsyqZtsu9ujJ3kTds3Xqdt2oIbuKxbApi4gQ0YMM0NgWgCVBDqvUy97x/3kTSqCJA0Epzv56PPzDzz6HnuFMScOeeeax3KrpT6i1IqWyn1plIqImQPSgghxCVJAjohhBAXs4h2JZefC7qvRms9A/gd8F/Wtt8BT2utLwfWAr+xtv8GeE9rfQVwNZBtbR8H/F5rPRmoAu7u48cjhBBCtKG01qEegxBCCNEnlFJ1WuvoTrafBBZorXOVUk7gjNY6SSlVBgzXWnut7UVa62SlVCmQprV2Bx1jFPCW1nqcdftfAafW+id9/8iEEEIIQzJ0QgghLlW6i+td7dMZd9B1PzI3XQghRD+TgE4IIcSl6nNBlzut6zuA+6zry4Ht1vV3gH8CUErZlVKx/TVIIYQQojvyTaIQQoiLWYRS6qOg2//QWjcvXRCmlPoA8+XmUmvbN4DVSqnvAaXACmv7N4E/K6U+j8nE/RNQ1OejF0IIIc5C5tAJIYS45Fhz6KZprctCPRYhhBDiQkjJpRBCCCGEEEIMUpKhE0IIIYQQQohBSjJ0QgghhBBCCDFISUAnhBBCCCGEEIOUBHRCCNFHlFKjlFJaKeWwbm9SSj3Uk33P41z/ppT664WM91KnlApTSh1USg0LwbmfVEpdNAuSK6XeVUp9wbq+XCn1Zh+co1fe80qpy5VSO3pjTEIIEQoS0AkhRBeUUm8opR7rZPvtSqkz5xp8aa1v0Vo/1Qvjmq+UKmh37P+rtf7ChR77EvclYKvW+gy0BFkepVSdUqpWKbVPKTWvpwdTSp1USt3Q24MMCv43ttv+rFJqVW+f70JprddqrRddyDH68j2vtf4EqFJKLbnQYwkhRChIQCeEEF17EnhAKaXabX8AWKu19vX/kC4t55uxPE9fBp5pt+2XWutoIA74b+AVpZS9H8fUnWuUUtdd6EH6+TkeqNZiXn8hhBh0JKATQoiuvQYkAnOaNyilEoDFwNPW7duUUh8qpWqUUvndZUjalaHZlVL/qZQqU0rlAre123eFUuqQlRnKVUp92doeBWwCRliZozql1Ail1Cql1LNBv/8ZpVS2UqrKOm9W0H0nlVLfVUp9opSqVkq9oJQK72LMY5VSm5VS5dZY1yql4oPuT1dKvaKUKrX2+V3QfV8MegwHlVJXW9u1UiozaL+WcsPmTIxS6l+VUmeANUqpBKXUBuscldb1tKDfT1RKrVFKnbbuf83afiA466KUclqP4cpOHmcGMBb4oLPnQWsdANZh3g9Dz/bcKKWeATKA9dZr9H1r+2yl1A7rdclXSj0cdJoEpdRG6/n6QCk1trOxBPkl0GWZpvX8H1NKVSil/q6UGhF0n1ZKfU0pdRQ4GrTtq0qpo9YYfmw9xp3W+/tFpZTL2rfb16TdOB5WSm23rn8/6H1bp5TyKqWetO4L5Xv+XWChUirsLM+5EEIMOBLQCSFEF7TWjcCLwINBm+8FcrTWH1u366374zFB2T8ppe7oweG/iAkMrwKmAZ9td3+JdX8ssAJ4XCl1tda6HrgFOK21jrZ+Tgf/olJqPPAc8C0gBXgdE1i42j2Om4HRwOXAw12MUwE/A0YAWUA6sMo6jx3YAJwCRgGpwPPWffdY+z1oPYbPAOU9eF4AhmECp5GYMkgbsMa6nQE0Ar8L2v8ZIBKYDAwBHre2Pw3cH7TfrUCR1vqjTs55GZDbVdbVeqwPAieA4ubNdPHcaK0fAPKAJdZr9EsraNwE/BbzulwJBI9lKfAokAAcA37a2ViC/B4Yrzop61RKLbDGdi8wHPMaPd9utzuAmcCkoG03A1OBa4DvA38GlluPbYo1Rjj7a9IprfUvm9+3mOesFPNvDEL4ntdaFwJeYMLZHoMQQgw0EtAJIUT3ngLuUUpFWLcftLYBoLV+V2v9qdY6YM3FeQ7oyTyre4H/0lrna60rMB++W2itN2qtj2vjPeBNgjKFZ/E5YKPW+i2ttRf4TyACuDZon99orU9b516PCS460Fofs47j1lqXAr8OenwzMMHM97TW9VrrJq31duu+L2DKFfdYj+GY1vpUD8cfAB6xztmotS7XWr+stW7QWtdiAp15AEqp4ZgP+1/RWldqrb3W8wXwLHCrUirWuv0AHUsqm8UDtZ1s/65SqgoTuP8X8B9aa38PnpvOLAfe1lo/Z42zvF1w+YrWercVVK6li9ckSBPmuegsS7ccWK213q+1dgM/BGYppUYF7fMzrXWF9cVFs19orWu01tnAAeBNrXWu1roaE4xeZT32Ll+TnrD+Pb0GPKG1ft06Zqjf87WY94EQQgwqEtAJIUQ3rAClFLhdKTUGmI4pvQNAKTVTKbXFKj2rBr4CJPfg0COA/KDbbYIdpdQtSqldVrlcFSa71JPjNh+75XhWuWA+JoPW7EzQ9QYgurMDKaWGKKWeV0oVKqVqMEFS8zjSgVNdZLXSgeM9HG97pVrrpqAxRCql/qSUOmWNYSsQb2XN0oEKrXVl+4NYWZz3gbutUshbMIFSZyqBmE62/6fWOh4THEwDfqWUusUaV3fPTWfO9pz06DVp5y/AUNWxoUf790AdJkMa/B7Ip6PioOuNndyOhrO+Jj3xP8BhrfUvmjcMgPd8DFDVw/MJIcSAIQGdEEKc3dOYzNwDmIxF8IfcdcDfgXStdRzwR0wp3tkUYT7gN8tovmLN43kZk2UYagUUrwcdV5/l2KcxpXDNx1PWuQp7MK72fmad73KtdSymhLF5HPlAhuq8qUY+Zk5aZxowJZLN2i8T0P7xfQdTCjfTGsNca7uyzpOogub1tfOUNeZ7gJ1WaV1nPgHGdPFYsLJGBzABYvN8x+6em84eR3fPyXmxslGPAj9ud+7274EoIIm274GzvY+6091r0i2l1A+s3/180LaQvuet+YUu4HBP9hdCiIFEAjohhDi7p4EbMPPe2i87EIPJEDUppWYAy3p4zBeBbyil0pRptPKDoPtcQBgmM+izMkLBbd+LgSSlVFw3x75NKbVQKeXEfPh2A+ez1lYMUIdp654KfC/ovt2YwPTnSqkopVS4au26+FdMueJUZWQqpZo/cH8ELFOmMczNnL1ULwaTHapSSiUCjzTfobUuwpQC/sFq1OFUSs0N+t3XgKuBb2I1sumM1roA0xxkRlf7KKUmArOB7KBxdfXcgHmdxgTdXgvcoJS6VynlUEolqU4atJyHZzDvl5uDtq0DViilrrSCpf8LfKC1PtkL54NuXpPuWO/lbwB3tCv1DPV7fj6w2SpPFUKIQUUCOiGEOAvrQ/AOIAqTjQv2VeAxpVQt8CNaGzyczV+AN4CPgf3AK0Hnq8V86H0RUwq4LPi8WusczFy9XKuj34ig46K1PozJFv0WKAOWYJpzeHo4tmCPYgKiamBju3H6rWNnYhqAFGDmMqG1/l/MvKp1mLlJzR1DwQRXSzDlbcut+7rzX5iSxzJgF/CPdvc/gGlokYNprPGtoDE2YjI/o4PH3oU/WccK1tyVsR4zp2uNtR9089xYfgb8u/UafVdrnYcpI/wOUIEJbK84y5jOynodHqH1+UVr/Q7wH5jHXoTJDN53oecKcrbXpCufwzQtOaRaO1b+cQC855djsutCCDHoKK0vpOJCCCGEGNiUUj8Cxmut7z/LfmHAh8BCK/MnLgFKqcuAP2utZ4V6LEIIcT4koBNCCHHRssoBPwQe0FpvDfV4hBBCiN4mJZdCCCEuSkqpL2IakWySYE4IIcTFSjJ0QgghhBBCCDFISYZOCCGEEEIIIQapTtfbCaXk5GQ9atSoUA9DCCGEEEIIIUJi3759ZVrrlJ7sO+ACulGjRrF3795QD0MIIYQQQgghQkIpdaqn+0rJpRBCCCGEEEIMUhLQCSGEEEIIIcQgJQGdEEIIIYQQQgxSEtAJIYQQQgghxCAlAZ0QQgghhBBCDFIS0AkhhBBCCCHEICUBnRBCCCGEGHA25m5k0UuLuPypy1n00iI25m4M9ZCEGJAG3Dp0QgghhBDi0rYxdyOrdqyiyd8EQFF9Eat2rALgtjG3hXBkQgw8kqETQgghhBADyhP7n2gJ5po1+Zt4Yv8TIRqREAOXBHRCCCGEEGLAOFZ5jKL6ok7vK6ovoqqpqp9HJMTAJiWXQgghhBAipLTW7C/Zz5oDa3iv4D0UCo3udN8bXrqBxWMWsyxrGeMTxvfzSIUYeCSgE0IIIYQQIRHQAbbkb2HNgTV8XPoxCWEJfPXKr5IUnsSv9vyqTdlluD2cr1zxFfJr89mYu5GXj77MjGEzWJa1jPlp87Hb7CF8JEKEjgR0QgghhBCiX3n8HjbmbmRN9hpOVJ8gNTqVf5v5b9yReQcRjggAopxRPLH/Cc7Un2FY1DC+efU3WxqifOvqb/HKsVd4Luc5vrXlW6RGp7J04lLuyLyDuLC4UD40Ifqd0rrzdHaoTJs2Te/duzfUwxBCCCGEEL2s1lPLS0de4tmDz1LSWEJWYhYrpqzgxpE34rCde57BF/CxJX8Law+tZV/xPiIcESwZs4TlWcsZEz+mDx6BEP1DKbVPaz2tR/tKQCeEEEIIIfpSaUMpzx56lhcPv0idt46Zw2eycspKZg2fhVKqV85xqPwQ63LW8Xru63gCHmYNn8XyrOXMSZuDTUkfQDG4SEAnhBBCCCFC7kT1CZ7Kfoq/H/87fu3nxpE3smLKCiYnTe6zc1Y0VfDykZd5Pud5ShpLSI9JZ9nEZdyReQfRrug+O68QvUkCOiGEEEIIETKflH7C6gOr2Zy3GZfdxR2Zd/DQpIdIj03vtzF4A17eOfUOaw+t5aPSj4h0RHJH5h0snbiUUXGj+m0cQpwPCeiEEEIIIUS/0lqzrXAbqw+sZl/xPmJdsdw38T6WTVxGUkRSSMd2oOwA6w6tY9PJTfgCPmanzub+rPuZNWKWlGOKAUkCOiGEEEII0S+8AS//OPEPVh9YzbGqYwyLGsaDkx7k7nF3E+mMDPXw2ihrLON/D/8vLxx+gfKmckbFjmJZ1jJuH3v7gBuruLRJQCeEEEIIIfpUg7eBl4++zNMHn+ZM/Rky4zNZMWUFt4y+BafNGerhdcvr9/LGqTdYe3AtB8oPEO2M5s5xd7J04lLSY/qvLFSIrvR6QKeUuhl4ArADf9Va/7zd/V8Bvgb4gTrgS1rrg0qpUcAh4LC16y6t9Ve6O5cEdEIIIYQQA1d5YznP5TzHcznPUeOpYerQqaycspI5qXN6rWNlf9Fa80nZJ6w9tJa3Tr6FX/uZlz6P5VnLmTls5qB7POLi0asBnVLKDhwBbgQKgD3AUq31waB9YrXWNdb1zwBf1VrfbAV0G7TWU3o6eAnohBBCCCEGnvzafJ7KforXjr2Gx+9hQcYCVkxZwRUpV4R6aL2iuL6YF4+8yEtHXqKiqYLM+EyWZS1j8ZjFLYudC9FfejugmwWs0lrfZN3+IYDW+mdd7L8UeFBrfYsEdEIIIYQQg9vB8oOsObCGN0+9iV3ZWTJ2CQ9PfpjRcaNDPbQ+4fa72XRiE2sPrSWnIodYVyx3j7ub+ybex4joEaEenrhE9HZA91ngZq31F6zbDwAztdb/3G6/rwHfBlzAAq31USugy8Zk+GqAf9dab+vkHF8CvgSQkZEx9dSpUz0ZuxBCCCGE6ANaa3YV7WL1gdXsKtpFtDOaeybcw/1Z9zMkckioh9cvtNZ8WPIhzx56ls15m9FoFqQvYFnWMqYNnSblmKJP9XZAdw9wU7uAbobW+utd7L/M2v8hpVQYEK21LldKTQVeAyY3l2d2RjJ0QgghhBCh4Qv4ePvU26w+sJpDFYdIiUjh/kn3c8/4e4hxxYR6eCFTVFfEC4df4KWjL1HtrmZCwgSWZy3nltG3EO4ID/XwxEUo1CWXNqBSax3XyX3vAt/VWncZsUlAJ4QQQgjRv5p8Tbx27DWeyn6KgroCRsWOYsWUFSwesxiX3RXq4Q0Yjb5GXs99nWcPPcuxqmPEh8Vzz/h7uHfCvQyLGhbq4YmLSG8HdA5MyeRCoBDTFGWZ1jo7aJ9xWuuj1vUlwCNa62lKqRSgQmvtV0qNAbYBl2mtK7o6nwR0QgghxOCwMXcjT+x/gjP1ZxgWNYxvXv1NbhtzW6iHJc5Btbu6pWNlRVMFl6dczsopK7k+/XpZcLsbWmv2nNnD2kNr2ZK/BZuyccPIG7g/636uSLkiZOWY3pISCr/9HdIe/zWOlJSQjEH0jnMJ6Bxn20Fr7VNK/TPwBmbZgtVa62yl1GPAXq3134F/VkrdAHiBSuAh69fnAo8ppXyYJQ2+0l0wJ4QQQojBYWPuRlbtWEWTvwmAovoiVu1YBSBB3SBQVFfE0wef5uWjL9Poa2Ru2lxWTF7B1KFTZW5YDyilmDF8BjOGz6CgtoDnc57nlaOv8MbJN5iUNInlWcu5edTN/Z7dLPvDf9O4bx+lf/hvhj/yo349twgdWVhcCCGEEOckryaPpRuXUuPpOCU+1hXLbxb8hqzELCKdkSEY3QD2yYvwzmNQXQBxabDwR3D5vf06hCOVR1hzYA2bTmxCobh1zK08NPkhxieM79dxXIwavA1syN3A2kNrya3OJTE8kXsn3Mu94+8lJbJvs2Vaa9yHD3PynnvRXi8qLIzMt9+SLN0g1usLi/cnCeiEEEKIgcXj97CveB9bC7ayvXA7J2tOnvV3bMrGmLgxTEqaxJTkKUxOmsyExAmE2cP6fsAD0ScvwvpvgLexdZszApb8ps+DOq01e4v3subAGrYVbiPCEcHd4+7mwUkPMjx6eJ+e+1KktWZn0U7WHVrH1oKt2G12bhp1E8snLueylMvO+7j+ujq8BQV4Cwrw5Be0Xi8swFt4Gt3Y2GZ/V2Ymwx97lIirrpKs6yAkAZ0QQgghLkhxfTHbCrexrWAbu4p20eBrwGVzMX34dOakzmH1p6spaSzp8HtDI4fyo1k/IrssmwPlBzhQdoCKJjPbwqEcjEsY1ybIy0zIxGlz9vfD6z9+H1Sdgv9ZBA1lHe+PS4d/OdAnpw7oAJvzNrPmwBo+KfuExPBElk1cxn0T7yMurEPvOtEH8mryeC7nOV499ir13nouT76cZVnLWDRyEU572/d9wO3GW3gab6EVqBUU4C0obAnc/NXVbfa3RUXhTEvDmZ6GIyGRqldfBZ+vwxicqanELl5M3JLFhGVm9unjHVQGQMa8OxLQCSGEEOKc+AN+Pin7hG0F29hasJXDlYcBGB41nLlpc5mTOocZw2cQ4YgAOs6hAwi3h7Pq2lVt5tBprSluKCa7LJvs8mwOlB0guzy7pVzTZXMxMXFimyBvdNxo7DZ7Pz76C6Q11JdB+TEoP2ouy6zrFScg4O3mlxWsqurV4Xj8HtYfX8+T2U9ysuYkadFpPDz5YW7PvF1a7IdIvbee1w6/wqY9z+IpKCSzIZo5tglMaErAdqYMb0EBvpIS816yKKcTZ2qqCdrSUnGlpZnrqea2PT6+JfNWtOpRql5+GbxB7zWnk8ipV6PsDup37oRAgLCsLOIWLyZ28W04hw7t76dh4AhhxrynJKATQgghxFlVNlXy/un32VqwlR2nd1Dtrsau7Fw15CrmpM1hbupcxsaP7bJc63y7XGqtKagtILu8Ncg7WH6QBl8DABGOCLISs5icPJkpSVOYnDyZ9Jj00Hdd9DZC+fF2QZsVuDUFZU9sTkgcA8njICnT/LzzGNR3zGiCMpmBmV8B14XNOaz11PLi4Rd59tCzlDWWkZWYxcrLVnJjxo2DK0AepLTW+CsrW0shg7JrnoICvEVFbQKuAFARq/APS2LI2CmkjJ3SGrilp+NISUHZevaez73jTtw5OR22h02cyJjXXsVXWkrNpk1Ur99A06efglJEzphB3JLFxCxahD02treehtAJBMBdDQ0V5qexAhrKg65btxsrIW9X51+09GHG/FxJQCeEEEKIDrTWHKo4ZLJwhVv5tPRTNJrE8ERmp85mbtpcZo2YRayr/z/cBXSAk9Un2wR5ORU5uP1uAGKcMUxKnsTkpMktmbzhUcN7f25QIADV+VagZv2UWQFcdX7bfWNGQLIVsCWNswK4sRCXAfZ2jcQ7ywg4wiBpPBR/CtFDYd734aoHwXFunRFLGkp49uCzvHjkReq99cwaPouVl61k5rCZMneqlwXq602gFlwW2TyfrbCQQENDm/3tCQntMmzpLdfzo5p4/thL/O3432j0NXLVkKtYlrWMhRkL+7QM2X3iBDUbNlK9YT3eU3kol4voefOIXbKY6PnzsbkGwLqDfp8JvBrKW4OxTgO0oO2NlaADnR9P2SEyESISzWXezi5O3PsZ8/MlAZ0QQgghAKjz1LGraFdLQ5PSxlIApiRNMaWUaXOYlDQp9NmvTvgCPo5XHTdBnjUn70jlEXwBM08oMTyRSUltg7wedxNsrGybYSs7arJvFcfB11pGiiumbdCWNNYEboljISz63B5QV3N2Tu2Edx41HzITRsH1/wemfBbOkp3Jrc7lyQNPsj53PQEd4KaRN7FiygqykrLObVyihfZ48BYVtQZqhW3nsvkrK9vsryIjcaWm4kxP71gWmZqKPTrqrOes8dTw2tHXWJezjsK6QoZGDuW+ifdx97i7SQhP6KuHitaapk8/pXr9Bmpefx1/eTm2mBhiblpE3OIlRM6Y3uMMYbe8Te0yZO2DsU62u6u7Pp49DCKTrAAtIeh6Yrvria3Xw+Mg+MuNx6d0/IIGJEPXWySgE0IIIc6f1poTNSfYVmAamuwr2Ycv4CPGGcO1qdcyJ3UO16VeR3JEcqiHel48fg9HKo+0zskrP8DxquMErG/mh0QMYXLyZBPkJUxgki2ShNqSjnPbGspbD6rsJpAKLpFsvh49tO0Hwb6iNRx9ywR8xZ/CkMkm4Bt/U4fzf1TyEasPrGZL/hbC7GHcmXknD05+kPSY9L4f5yCnAwF8paV48/M7NB3xFBbiKy42WdpmTifOEcNxpVqBWloarrTUluv2hIRey4L6A362Fmxlbc5aPij6gDB7GLeNuY1lE5cxIXHC2Q9wAU0+tM9H/c5d1GxYT+1bbxNoaMAxdCixt91mmqlMnIgC8NS1y5ZVdpI5a75uZdi8DV2f2BXdLgBLanc9oeN2Z+SF/5uUOXR9SwI6IYQQ4tw0+ZrYc2YP2wpNQ5PCukIAMuMzW+bCXTHkiouzm6TWNFaeIOfUu2QX7ye7+hgHmko5iadll1Svj8luN5NxMSVyBFmJE4hJzmoN2hJGgX2APDeBAGS/Alt+ChW5kD4TFj5CYOQsthVsY/WB1ewv2U9cWBxLJy5l6cSlJIYnhnrUfcZbUkLht79D2uO/7tGaalpr/FVVJlDrrFvk6dNoT+t7A6VwDBnSGqi1BG4m2+YYOhRl7//5h0crj7IuZx0bjm+gyd/EtKHTuD/rfuanz+98PuS5BiiBADRVWUFX2wxZoKqY2n2HqdmTR92xagiAK14TN7KB2PQ6XNH+TkasTBas02xZV1m0BFN2HCrS5bLvSEAnhBBCnN3putMtc+F2F+2myd9EuD2cmcNnMjdtLrNTZzMiekSoh9l73LVtM2wtc9uOg7e+dT9HBCRlUps0mkPRCWQ7bWT7azlQl09hfVHLbqNiR7Vm8pKnMCFhwsBaCN3vhQ+fxfveL3hd1/BkynCO4WF41HAenPQgd427a2CNt48UrXqUqhdeIP6++xj+yI8ACDQ04C0sbBOoeQqt6/n5BOrr2xzDHhfXklFrP5fNmZo6MOaMdaHaXc0rR1/huZznKKovYkTUCO6beB93jbur7dITXZUQhsVA1u0dSxt7Mt8sMgmfjqP2BFRn19B40pRBRkxIJ+76GcTcMB/HsJEmSIuIB2m806skoBNCCCHOxwD+xtYb8PJRyUctywocrz4OQFp0WstcuOnDpg/uhbub12xrbkJSfrR1nlvdmaAdFcRndF4iGTOiy7lnVU1VLU1XmufklTSYzpPNC6E3z8WbkjyF8QnjcdlD82G/3lvPS0de4pmDT1PcUMI4r58VlZXcPHIRzgX/Yeb1XeS8JSUcX3gD2usFm42wiRPwFZfgLy9vs58KDzeBWmpax7lsaWnYo89xruMA5Av4eDf/XdYeWsve4r1EOCJYPGYxyyYuIzMhE1bFA118po9NtTJjCZ3MM+tkzllYbKcljZ6CgpZmKp5jx8HhIHrOHOKWLCb6+uuxRUT07ZNwiZGATgghhDhXA3BORVljGdsLt7O1YCs7T++kzluHw+Zg6tCpzE01Qdyo2FGDq5Oh1lBfGpRhs7JsZUeh8gQEghkouREAACAASURBVBZGjkhsG7Q1B24Jo8HZO+uplTaUtumsmV2WTaXbNL5w2ByMix/XEuRNTp7M2PixfVq6WtZYxrpD63j+8PPUemqZPmw6KyavYHbSZaidv4OdfzBNW65aDvN+AHGpfTaWUNF+P7XvvMOZRx9rE7zZhw4lZu6clrLI5rls9qSkwfVv4ALlVOSw7tA6NuZuxBPwcA0RLD+TR61N8duEeM447Azz+flmZRW3OZJ6vcmH1hp3To5pprJxI77iYmyRkcTceCOxS5YQdc1MlMNx9gOJbklAJ4QQQpwLreH/TYC64o732V1mHpPdZeZZ2Z1mnTG7y7Smt7us280/nd12dPH7bfcJ2Bxk1+WxtewjtpXsJ7vqKABDIpKZM+I65qTN45rUa4lynr1zXr/oLqPpaTAdI5vLIoM7SQZ3sLOHWWu2NXeRDMq2Rfb/3DCtNWfqz3Cg/EBLFu9g2UFqvbUAhNnDmJA4oWV9vMlJkxkVO+qC13nLq8njqeyneO3Ya3gDXhZmLGTFlBVcnnJ52x3rSmDb/4O9qwEFM74Is78NUUkXdP6BINDYSNWrr1Lx5FN48/I63K/Cwsh8+60ezaW7qDXVwEfrqNzzR17ylfN8XBwldoXSGh0U2IYHNKtG38lt83/cZ0PRfj8Ne/ZSvWE9tW+8SaC2FntyMrG33kLckiWET5kyYIPt811Hs79IQCeEEEKcTUMF5G6BY++YnzYlfe1kXAt+j1mI1t/84zHZJL+ndVvA2n4Oqm2KnRERbIsIZ3tkBBV2OzatudztYU5DI3MbG5ng8dLykUjZzjFo7CrovMD9T+2AHb8Da504wMyhSRpv5rvVFLR9oLFp7dZss67HpQ/4uTdaa/Jr800Gz8rmHSw/SKPPZHMjHZFkJWW1CfLSY9I7fJDt7APkqLhRrP50NW/nvY1d2fnM2M/w8OSHGRU3qvtBVeXBuz+Hj58DZxRc+3WY9VUzZ2qQ8ZWVUbF2LVXrnsNfXU34FZdjj46hfvfuNgtx43QS/9nPtsylu+SUH4fdf4YP14KnFtJmwMwv4514Kwtevokqd8f10xSKGFcMDpsDp83Z4bLNNrsDp3LitDtxKIe57G7/9vf5NLH7jhGz5UMi9hxEeX3404biv+FauGkejoy0Lo8RvL0/AsCNuRtZtWMVTf7WJUrC7eGsunbVgAnqJKATQggh2gv4oXCfFcC9ba6jITwexi6A3HdNs4D2znVdIq3NufyeToM+7fdwtDqXbSX72Vr2ER9XH8dPgDhHJNfFjmNu3FiuixpJvHJ2HzT6fT0LMs8lEO2qScK5sDth8l3t1mwbA64BklXsJf6An5M1J1uDvLJscipy8ARMQB/jimmzPt6Z+jM8sf+JNh8gbdgIECDGGcO9E+5ledbynq+j16wkBzb/GHI2QGQyzPkOTFvZayWpfcl9/DgVTz5J9d/+jvZ6iV64gKSVK4m46ipO3HkX7pycDr8TNnEiY157NQSjDRGt4fhm+OCPcPRN80XLlLtg5pchdWrLbpc/dTm6izl0SycuxRfw4Q14u7/0e/Hpdped7OfTvk7PEyyqUTPzsGZ2tmZSnsYGHB0O2yfb2DFJUR3VddDmUI7Og8agQLO7wLInl6sPrKbGU9Ph3MOjhvPmZ988++vSDySgE0IIIQBqTpsA7vg7cHyLadOtbOaDUOYN5mfEVSZD1Idz6Bq8DXxQ9AHbCrexrXAbZ+pNNnBi4kTmpM5hbtpcLku+7ILL9i5YwB8U4J0lIPyfRXTehEHBqo6ZgkuBN+DleNXxNkHe0cqj3X4AjnHF8ObdbxLtusDGHQX7zOLkJ94z2dD5P4ArlpqM6wCitaZhzx4qVq+h7t13UWFhxN15B4kPPUTY6NGhHt7A4a4z2dfdf4ayIxA1BKZ/HqaugJihHXZf9NIiioK6uDbriwAloAP4A368AW/LT3PA11mQ6C8pwf7WDlzvfIAztwBts9FwZSZV8y6jYsY4PGH2swebXZ2nh0Fo8++cjULxyUOf9Orzdb4koBNCCHFp8rkhb2drGWVJttkePcwK4BbCmPldz83qxS6XeTV5LevC7TmzB2/AS6QjklkjZjEndQ6zU2czNKrjB7NBo6s26eea0bzIuf1ujlQcYdnryzq9v9c/QOa+C28/Cqf3Q/J4WPDvkPWZ/lkcvRva56PmjTeoWL2Gpuxs7ImJJCxbRsKypTgSL9519M5ZxQnY81fY/4yZazriKpj5TzD5jm7XbBsMJYQA7qNHTTOVDRvwnj6NCg8nZsECYpcsJnr2bJSz7xoOaa3xaz++gI/Fry6muKHjnGnJ0PUSCeiEEEKck/LjrVm4E1vB22DKkkbOas3CDZnU5x9oPX4P+4r3sbVgK9sLt3Oy5iRg1jubk2aycFcPuTpkbfB73QDsCjqQ9WcGBa3h0HrY/BMoO2yCgoU/gjHX93tg56+rp/rll6h46mm8p0/jGjWKxBUriLv9M9jCB35ZaL/Q2vzt+uCPcHiTqRiYdDvM/AqkTe/xazbQm3wE04EAjR9+SPX69dRu+gf+6mrs8fHE3HIzcUuWEHHVVX06l24wBMAS0AkhLl4DeJ0w0U/cdXByW+tcuMoTZnvC6NYAbtRsCOv7taeK64tNGWXBNnYV7aLB14DL5mL6sOkmiEudS3psep+PI2Tk32OPheQDZMAPHz8P7/7MZFNHzYEbVkFajz4jXhBvcTGVzzxD5QsvEqitJWLaVJJWriR6/nxUF+sEXnI8DfDJC/DBn6D0kFkTbuoKU1oZOyLUo+s32uOhbvv71GxYT+3mLeimJpypqcQuXkzcksWEZfbNmosDPQCWgE4IcXGSjMClSWsozjYZuGNvw6mdZk6XMwpGzzEB3NgFpgFHH/MH/HxS9knL4t6HKw8DMCxqWMu6cDOGzSDSGdnnYxGDT8g+QPrcsHcNbP0VNJTBhNtg4X/AkKxeP1XT4cNUrF5D9caNEAgQs2gRSSseJuKKK3r9XINWVZ4pq9z3lJnXO+wyU1Y55e5B0cymL/nr6ql9+y1q1m+gfudOCAQIy8oibvFiYhffhnPoIC5TP0cS0AkhLk5dztlJg3/J7v/xiL7TsqTAZhPI1VqlakOnmOAt8wbIuKbbOSXno7MP3NeOuJb3T7/P1oKt7Di9g2p3NXZl58ohVzI3bS5zUueQGZ85YNdaEqKFuxZ2/Tfs+K25fsV9MP+HkDDygg6rtaZ+xw4qVq+h/v33UZGRxN99N4kPPYgrLa2XBj/IaW2W+vjgj6YjKUDWElNWmTEr5HMcByJfaSk1mzZRvX4DTZ9+CkoROWMGcUsWE7NoEfbY2FAPsU9JQCeEuPgEAvBYQtf3J08w3zYPmdR6mTh6wK9vJSwBPxTuNxm44++YJQV0wFpS4PrWLFwfliF1VhKnUC2twBPDE5mdOps5aXO4dsS1xLou7g8T4iLWUAHbfw27/2L+7U1bAXO/B9FDzukw2uOh+vXXqVjzJO7Dh7GnJJN4/wMkfO5e7PHxfTT4QcbbBAdeMoHcmU8hIgGufgimfwHiL+Jy7F7mPnGCmg0bqd6wHu+pPJTLRfS8eaaZyvz52FwXydzkIBLQCSEuLsUHYeO3TffCzoTFmrkhJQeh8iQtrdQd4ZAyoW2QNyQLYlPl29CBoKbIKqN8x6yz1FQFqLZLCqRefV5BuT/gp85bR42nhhpPDbWeWmrc1mW7bTXeGmrdtWSXZ+PX/g7HinZG85dFf2FS0iRsSub+iItIzWl47xemo6IjDK75J7j2GxDRfTDmr6mh6sUXqXj6GXwlJbgyx5K0YiWxSxZflB+sz0vNaaus8kloKDf//8z8Mlx2L7ikJPt8aa1p+vRT0ynz9dfxl5dji4kh5qZFxC1eQuSM6RfNHE0J6IQQFwdPPbz7c9j1BxO0ZS2BT1/sfg6dpx5KD0PJIRPglRw012uDusuFxQYFeEHBXlRS/z6+S43PDXm7rCzcZii2WttHDzPLCWQuNF34rCUFmnxNHQKwand1y7b2l8EBW523rtuh2JWdWFcsMa6YlsudRZ1/YTCQ1iUSok+UH4ctP4UDL5us+OxvwYwvdwg8vIWFVDz9DFX/+78EGhqInHUNSStXEjV7tpQcgymrzN9tsnGH/m6ynxNuhWu+Yr507OPn6LUPC/nVG4c5XdXIiPgIvnfTBO64KrVPzxlK2uejfucu00zlrbcJNDTgGDqU2NtuM81UJk7s9n050J8vCeiEEINfzkZ4/ftQUwBXPQA3PmY+6J9vV72GCijNaQ3wiq1gryloAeSoIW0zeUMnmwxfWEzfPc6LWEAHqC0+QO2xN6k5tZXaoo+oCXiodTipSRxFTcJIamKGUGN3UOut7ZBJ8wQ83R4/whHRJiiLdcUSG9Y2SGtzf1hsy34RjogO/9H3a1v5i4i3pITCb3+HtMd/jSMlJdTDERei6GN458dw7C3zRcu878PVD9J46AgVq1dT88YbAMTeeitJKx4mfNKkEA94gPC5IftVMz+x6CMIi4OrH4AZX4SEUf0yhNc+LOSHr3xKo7e1yiDCaednd102oIKUvhJobKR282Zq1m+gbvt28PlwZY4lbvESYhcvxpXW9jkYDM+XBHRCiMGr8hRs+lc4sskEVosfN80v+oLWUHumNchrzuqV5pi1zJrFZ3Qs20we3+sNOfrChXbVc/vdraWJwaWK7TJiLZfuKmoaSqnx1FIX8KG7+ULaruzEuGLaBGQxrpg2QVmb7e3ud9p6dwHawbAu0UBUtOpRql54gfj77mP4Iz8K9XBEbzi1A/3WKup2f0TFsWQaTmtsUVHE33sviQ8+gHP48FCPcGCoPQN7V5uf+lLz/8LML8Pl9/XLsinBrv35O5yuauqwPcxhY+aYS6v6JKKhlomHdzP54E7SC48CkJ82nuysWeRMnEFjRDQf5Jbj9gVIaKrhB3ue5efT76cyPJbU+Aje/8GCED8CQwI6IcTg4/PArt/Du78AZYP5PzDzOextP7T3S9vvQACqTgaVbVrBXtkRCPjMPsoOSZkDthGLP+Bnfe56frrrp20CFJfNxT0T7mFCwoSWAK3GXWMyZJ3MMXP73d2eJ8IRTow9klitifU0ENNYTazPTyw2YuLSiU3OImb4lcQmZnbIpEU6IgdcmdZAX5colLTPh/f0aTx5+XjyTuE9lUfT0aM07Nxpvhyx2xn22KPELFiAI6GbBkZiQAu43VT//e9UPPkknuO5OKJtJGZWEn/NSOy3roJxi2QOcsE+U1aZ/apZQmXcTaassp8Xbs+vaGDr0VLeO1zKmweLu9zvyvRLt0FNQnUpVxzZzZVHPmBoxWn8NjuHR07hb0mX8cGwSXzhwHpuPbmLjaNm8Ycr70IBJ34+MP7mS0AnhBhcTr5vmp6U5sDExXDLL0w5ZTv9nUHRWuPTPrx+r7n0NOCrOI639BC+0iN4y4/hqzyOt7YIH+BV4HOE4Y1NxRefjjd2OL6Y4Xijh+ALi8arffgCPrwBr/lpPq7f27K9ty4DOtCjx2hTtq5LFJtLGJ0xLeWKMa4YYgOamNMfE3tqJ87jW1rnJw6ZDJnNSwrMGhQZTNFWwOPBW1CAJy8Pb14enlN5ePLyTABXeBp8vpZ9VXg4KiyMQE2NCeiChI0fT+T06UTOmEHk9Gk4EhP7+6GIc+SrrKTq+eepeHYt/vJywrKySFq5gthFi1BH1sPmn0DlCUi/Bm54BEZeG+oh9y+fx8yL++CPULAHXDFw1f2mrLIf1sAEaPL62ZVbzntHStl6pJTjpfUApMZHUNngocHTsanTQMo4hZLWGndOjmmmsnEjvuJiGuwuwvxe7GjcNicrFv2QyGFDB8zzJQGdEGJwqC+DN/8DPl5nyhpv+RVMuLnL3bua4xTtjObucXe3Db56ECR1dT34si/ZsOG0O3HYHDhtTpy21us9urQ7cah2l0HH+v1Hv+/0vArFG3e/QYwrhihn1NmzZAE/nP7QNDM59g4U7rWWFIgzSwmMtRqa9OGSAqL3BBob8eTl481vF7CdysNbVNQmOLNFReEaORLnyAxc6Rm4RmbgysjAmWHWLTu+aBHa3ZrFVS4niQ89RFP2QRo+/BDdaBoYhY3LNAGe9eNITu7fBy265MnLo+LJp6h65RV0UxNRc+aQtHIFkddc0/Zvg98L+5+G934JdWcg80Yzh3n45aEbfH+oKzWdKvf81TzuxLGmrPKKpRDet0uXaK05XlrHu4dLee9IKbtPVOD2BVrKKOeNT2He+BTGpkTxt49OD/g5YQOF9vt587l/oJ74JWm1JSjAq2y8PWYWY37y6IB5viSgE0IMbIEA7H8K3l5lulJe+3WzBlIXrZxP1Zxic95mfr3v110eMsIR0WVw0/6yNwKm7o7Vct1Tj7MqH0fFcZzluTjKjuIsycHRVIVDgx36tBHLBTX5qD1jgrdjb5sFvhsrabukwEIYcTXYHRc8TtH7/HV1eE6dwpufbwVtJmDz5OXhKylps689Pt4EbBkjcaWn4xqZgTMjA9fIkdgTEroM+ItWPUrVyy+D19u60ekk/rOfZfgjP0J7PDRmZ9Owew8Ne/bQsH8/usHMTXWNGUPkjNYAzznk3NY/Exeu4cMPqVjzJLVvvQUOB3FLlpD48EOEjx/f/S96GmD3n2H746ap1OS7YMG/91uWqt8UfQy7/mjWkPN7zBdXM79i/v71YVv8miYvO46V8d4RU0p5utpUpGQOiWbuuBTmTUhh5uhEwp0dS/sHetfGgcRbUsKRhTdi87Y23wq4XEx45+0B09xJAjohxMB15lPY8G0o2A0jZ8PiX5sAJkhABzhYfpDNeZvZnLeZ49XHAXDYHJ1mzQZVF8J+bMRyTiWqPg/kW0sKHNsMxZ+a7dFDWxf1HrugZUkBEVpaa/xVVaYssnlOW1CJpL+ios3+9pRkE7BlZODKSDcBW8ZIXBnp2OPizmsMuXfciTsnp8P2sIkTGfPaqx3H7PXSdPAgDXv2UL97N4379hOoNyVjrlGjWks0Z0zHOXToeY1JdE/7/dRu3kzF6jU0fvghtthYEu67j4Tly3EOPcegurEKdvzWLCvjc5uujvP+dXBn6v0+yFkPH/zJrHvqjIIrl5olHFLOEuiep0BAk326hveOlPDekVL251XhD2hiwhxcm5nEvPFDmDs+mbQEWbuuN53tC6mBQAI6IcTA466FLT8z8w8iEmDRT+CK+1omkHv9XvYU72Fz3ma25G+hpKEEu7IzdehUFmQs4Pr06/mw5MOLtwthHzVi2fjuf/BE7qucscGwAHxzzJ3cNv/H5s6KE61llCe2grcebE7TVTRzoQnkhk6RBgghorXGX1ZmlUTmt8myefLyzNy1II7hw62AzZRGOptLJNPTsUVFhehRdE37fDQdOmQyeLt307BvH4E6s36gc2QGkdOnEzVjhsngSVfFCxJobKT6tdcof/JJvKfycKamkvjQQ8TffdeFvzdqi2Hbf8LeNebv0IwvwuxvD64vfxoqWssqawohfqQpq7xy+VkXWT8fZXVutlnNTLYdLaO83mSJLkuNY+74ZOaNH8JVGfE47RfHAtkD0bl+IRUKEtAJIQYOreHg3+AfPzTNM6Y+bOZdRCZS761ne+F2NudtZlvBNmq9tUQ4IrhuxHVcn3E9c1PnEh/e9j/TS64Loc8DFcdNkFd8sDXgqzwJWH+/HeEmezd0cttg79QOWP+Ntgux210w8jqoyjPHBfPhZdyNpqRo9JxLet29/i5Z0oEAvuJik1nLb9+IJK+lRBEAmw1namprwNYcvGVk4ExLwxYe3mfj7A/a76cpJ6e1RHPv3pag1ZmWZjVYmU7UjOk4U6WMrCd8ZWVUrltH5brn8FdVEX7ZZSR9fiUxN9yAcvRyuXTlSXj35/Dx8+ZvyLVfh2u+2u/t+8/JmQOw+09mfVNfE4yeZ8oqx9/Uq92Kvf4AH+ZVtWThDhSa93VSlIs545KZNyGFOeNSSI6WRlKiVa8HdEqpm4EnMFM+/qq1/nm7+78CfA3wA3XAl7TWB637fgh83rrvG1rrN7o7lwR0QlxEKk7A698zi9QOuwxue5yy5NG8m/8um/M2s6toF96Al4SwBOanz2dBxgKuGX4N4Y7B/cG0X3jqofRwUEbPCvZqg+fMKVqCvjaUaT3enIVLHCNZOPpuoVnt8+EtKsJzKq9jI5K8fLQnaAF1pxNXWpoJ0to3IhkxAuVyXchDHFS034/7yBEadu+mfs8eGvfsxV9dDYBzxIiWAC9y5gycqakDbgmMUHLn5lKx5kmq//Y3tMdD9IIFJK1cQcTUqX3/PJUcMh0xczZAZDLM/S5MWzlwut4G/HB4k6kWObkNHBFwxedMWeXQ3lsovaCyga1HynjvSAk7jpVT6/ZhtymmZiS0ZOEmj4jFZpP3rehcrwZ0Sik7cAS4ESgA9gBLmwM2a59YrXWNdf0zwFe11jcrpSYBzwEzgBHA28B4rXXHvqoWCeiEuAj43PD+b0wZjs3Byeu+xuaEIWwueJdPSj9Bo0mNTmVhxkIWZCzgypQrsQ+AtdsuCg0VZj5eyUHY+J0udlKwqqpfhzXQBAKaigYPpbVuSmrdlNQ08eMNB6lp6jhHsydtv7XHg6egsCVIC+4c6Sks7NDu35We3tqIpGVe20icw4eh7PJvoTM6EMB99GhriebevfgrKwFTbho5fVpriWZGxiUX4Gmtadizh4o1T1K3ZQvK5SLuzjtJfOghwsaM7v8BFew1ja9OboO4dJj/Q1NmH6q/9Y2VsP8Z2PMXU6EQl27KQ696oFfKQ5uXFGgO4oKXFJg7PoV545O5NjOZ2HDnWY4khNHbAd0sYJXW+ibr9g8BtNY/62L/pcCDWutb2u+rlHrDOtbOrs4nAZ0Qg1zuewQ2fpvs2jw2j7yCzRFh5NbmAZCVmMWCjAUsyFjAuPhxl9wHrn73+BSozu+4PS4d/uVA/4+nH3h8AcrqWoO0EitgK611U1pr3a5xU1bnxhfo/P+/hKYafrDnWX4+/X4qrbbk31iQyez0GCapWnRBfodGJN6iIjMP0mKLimobsI3MwJmejmvkSBwpKag+7JJ3qdCBAO5jx0x5plWm2dwMxjF0qNVkxXTRdI0addH+vdE+H7Vvvkn56jU0HTiAPT6ehOXLSVi2FEdSUogHp02X3HceM0ufJE8wHTGzlvRfVUBJjimr/Ph503hq5GwzP27CrRfUpdcsKVBvulEeKeWD3HLcvgAuh41rxiQxd1wy8yekMDYl+qJ974m+1dsB3WeBm7XWX7BuPwDM1Fr/c7v9vgZ8G3ABC7TWR5VSvwN2aa2ftfb5H2CT1vqldr/7JeBLABkZGVNPnTrVk7ELIQYQb00hezZ9i80le9gSHUOJDezKzrSh07g+43quT7+eEdGDuPvZYPTJi7D+G3hr3BTuSCDt2kocsWGw5Ddw+b2hHt05qXf7Og3SSmqbzGWNuV7Z4O3wu0pBYoSToVFOhkc5GBppZ0iEjZQIO8nhdpLCbSSFKX7wwodU1TRwz5HNzDqTzeGEDE7FDiO1vpzhdWUkN1W3PXBsLOGjRrYL2sylPTFRPsT1M601ntxck73bs4f63Xvwl5UB4EhJaQ3wZszANXr0oH99/HX1VL/yMhVPPoX39GlcI0eSuOJh4m6/HVtERKiH15bWZlHuzT8xjZ5GXG3mUo+9vm/OFwjA0TdNWWXuFrCHweX3mLLKC1g3zywp0Lqwd2GVmZ88NiWqpRvlzNFJRLgkyy4uXG8HdPcAN7UL6GZorb/exf7LrP0fUkr9HtjZLqB7XWv9clfnkwydEINHnaeO7QVb2fzx/7Ct6jB1NkWEsnNd2lwWjLyRuWlziQs7v5boopd88iJFqx6h6qAmfpJi+KpHLyiY04EA2udDe7zg86K9XnM7+NLrQ3s9aK8XOr3Pi/Z50R4v9Y1u6uoaqa9voqG+iYZGN00NTTQ1efA0uvG4PfjcHrTPhyPgxxnwYdcBHAEfTh0gQgUIU5ow7cdFAKf2Yw8EsPt92AJ+lM+MIbjk8VxUuaJwjR5F0vixFEUl8SmxbG8IY78vmjpXJMPjwrkuM5k545K5LjNZmhoMIFprPCdOtgR4Dbt34ystBcCenEzk9GktnTRdY8cOmgDPW1xC5bPPUvnCCwRqaoiYOpWkFQ8Tff31A79c1++DT543zVOq82H0XFi4CtKm9s7xm6rho3Vm2YHKExAzAqZ/HqaugKhzz1Y2Lymw1epIuS+vEn9AEx3m4DpZUkD0sVCXXNqASq11nJRcCnHxKWssY0v+FjbnbeaD07vwah8Jfj/z7XEsmPZ1rplwlzQ1CTHt9eI9fRpPXh6NB7Ip+93vwO8Hm42o+fNMuV9zYNVZQGYFai37BN2Pv8sp0L3Cq+z4bXYCdjsBuwMcDpTDiXI5sTmdOFxOHGEunNaPcjpRDoe5dDpRTge0bHO13udwoFyt+9KyvfX3lNNJzl+eJvzjvTh0AK/NTt3C27j2t7/oMM78iga2HS1j+7FS3j9WTnWjyQxmDY9lzrhkZmcmM6OLxX9FaGit8Z46RX1QiabvzBkA7ImJRE6b1tJoJWxc5oAri206fISKNWuo3rgR/H5ibryRpBUPE3HllaEe2rnzuWHvatj6n9BQBhMXm1LMIVnnd7yyY6as8qN14KmD9JmmW2XWErCf25y1sjo324+WtWThmpcUmJIay7zxKcwdl8LVIxNkSQHR53o7oHNgmqIsBAoxTVGWaa2zg/YZp7U+al1fAjyitZ6mlJoMrKO1Kco7wDhpiiLE4HKy+iSb880i3y1NTWwRLKwsYUHAxZXX/xj75fdKp8R+FHC78RYUWB0TTwUtMJ2Ht7CwTeClae136Y+MJio9tV0g1BwEOdtuD7pfOZ14lY2GgI16P9T5FbU+TbUPqj3mstIdoMKtqfIG8CoHfpsNn82BT5nLqKgw4mIiiYuJ3XPsfgAAIABJREFUICEuioTYCJLio0iOjyQlIYaU+EiGxIYTFdbL7dR7yFtSwvEbF6Hd7pZtKiyMzLffwpGS0uXv+QOaA4XVbD9Wxrajpew7VYnXr3E5bEwflcDszBTmjEtm0nDpaDeQaK3xFhSYDN7uPdTv2Y3vtOkSa4+PtzJ4ZqHzsPHjQxLgaa1p2LmT8tVrqN++HRURQfxdd5H40IO4MjL6fTy9zl0LO/9gFij31sPl98H8H0DCyLP/biAAxzebsspjb5klWabcDTO+BKlX93gIzUsKbLXmwn1aaEqrE6NczB2XzNzxZkmBlBjJvov+1RfLFtwK/Bdm2YLVWuufKqUeA/Zqrf+ulHoCuAHwApXAPzcHfEqp/wOsBHzAt7TWm7o7lwR0QoReQAfILstuCeJyq3MBq6lJ+DAWHHiDcdXFqOlfMN+q9sHCqwICDQ148vPxnGptvuHJN804fEVnzLwUiy02tnVNMqsZx54yD0Me/zGuQGu5odvuJP93a1ly/WWA+cBY3ehtaRZSEtQ4pLTOzFlr7gRZ5+5YtuiwKVJiwhgSE0ZKTHjL9SGxYQyJCbe2h5EcHYbLMbC/0S5a9ShVL78M3qB5eE4n8Z/9LMMf+VGPj9Pg8bH7RAXbj5ax/VgZOWdqAfMB8dqxSSaDNy6F1PgBNs9J4CkobFOi6S0sBMAWF2cyeFYnzbAJE/q0vFF7vdRs2kT56jW4c3KwJyeTeP9y4j/3ORwJCX123pCpL4ftv4bdfwEdMMsczP0u5L5rGqpUF0Bcmpl3N+EW0+Dkgz9B+VGIHgrTPg/TVkD0kB6drrCq0QRwh0t5/1hZy5ICV2fEmyzc+BSmjIiTL2BESMnC4kKIc+b1e9lzZg+b8zezJW8LJY0lbZuaRI9hxJZfmAnmw6+ExY+f07egonP+mho8efl4806ZVvfWGmXevLyW+T7N7ImJ7RaVHtmyRpk9vmNQ/Yfbv8R1R3bgCiqK8Cg7b4++hm23rbA6P7rx+AMdfjfSZW8JxoY0B2rtgrQhMWEkRLoumg89uXfciTsnp8P2sIkTGfPaq+d93JLaJt4/VmZKNI+WUVJrMoBjkqOYbc29mzU2SdqZD0De06etBiu7adizF2+e6dhri4mxAjzTZCU8a2KvBHj+2lqqXnyRiqefwVdcjGvsWJJWriB28WJsYZdAhqi64P+zd9/hUZVpH8e/J5Pee0/ohA6BACKiAgqyroK6uhZ21RWxrr2uZV0LFiyLBQUU26vrrg0LNgRRkCJIQu89jTTSk8mU8/4xISTUACGThN/nuuYKOec5Z+4hlLnneZ77hp+fhfQPwLAATqj3gRQenmB4gqPaVVjltJugxzjwPHJ/xmqbg6Xbi+pm4bbklQMQH+LLWSmuZZSnd44kxE9/B6XlUEInIo1SXlPOwuyFzNs1jwWZCyi3lePn6cfQ+KGMSB7hKmri4QMLX3I9PH1cn5Cm/c19vYRaGdM0cRQXY9vZMGHb169sXx+tfTyjoxvMstU1lU5OxhIY2OjnXZ9TytaxF9GpNPugc1uD4/lo4iRXYnaIJC062JdANy17bOtM02RzXnltcpfP0u1FVNY4sHgY9E0M4YwuruWZ/ZJCtUenBbLl5tbN3lX+toya2qrcHoGB+A8YUNcmwbdHDwzPxv8dsmVnU/Te+xR//DHOigr8Bw8m4m/XEjBsWIvby9csCrbAtDPAVnXwOS9/uPorSDz8+9z6LQV+2ZTPknotBQZ3COesrlGc1TWKztFqKSAtlxI6ETmsBkVNcpZic9oI8wnj7KSzGZE8gtPiTttf1GTLXPjmHijaBr3+BKOfgqBY976AFsg0Tez5+fuXRdZvKr17N86ysv2DDQOvuLiDe5QlJ+OdlHRC5caziqv4IiOLL9Kz2bin7LDjGtMoW5pHjd3Jil17Wbi5gAVbClidWYzThEAfT07rGM4ZnV3LMztFBeiNZwtk25PnSvBqk7ya7dsBVx9Cv/798R80kICBA/Ht2dNVjAfXXs2su+4m8aUXseXlUfT2O5R+69qNEnzeeYRfey1+vXq67TW1GI+F4tr5eyADHis+6GhZtY1ftxTWVaTc11KgY1RAXQKnlgLSmiihE5EGDlXUJDEwsa7Jd7+ofljqz7iV5sD3D8LazyG8E5z/wsnrF9RKmE4n9tzcerNsDfe1mVX1Pkn29MQrIf7ghC25HV6JCXh4H3l50LEorqxh9uocvkjP5rcdrqbK/ZNDGZeagIcBT83eQJVt/5JLPy8LT1/cm3GpCU0WgzSdkkobi7a6krtftxSws7ASgLgQ39rkzlVBM0LtEVoke36+a4lmbSXNmq1bATD8/fFPTcV/4ECq1qyhfO5cLFFROPLy8PD3J/Syywj/61/wilevzjov9XK1NjhQSBLcuQan02RdTmldY+8VO/dir20pcHqniLqllEnhaikgrZMSOpFT3BGLmtQmcV1Cuxz8ib/DDsvedDV/ddTAsLth6O3gdWq0ITDtdle5/wMTtl27sGVmYtbU1I01vL3xSko6qBCJd7tkvOLijmm51bGqtjn4cf0eZqVn8/OmPGwOk05RAYzrl8DYfgkkR+x/AzMrPYvJ328ku7iK+FA/7h2domSuFTlce4Qe+9ojdIlkYHu1R2ip7IWFVC5bXldoxbp5c4PzETfdRMS112AJDnZThC3Xsi+n0ev3h/Ez9v+7W2V681W7B1gSMJJfNudTUO461zM+uG4WTi0FpK1QQidyCjpaUZMRSSOIC4w7/A0yf4ev74DcVdBpJPxhMkR0ar4X0EycNTW15f53HrBEche27OwGDagNP7+6hO3AQiSeMTHNurfF4TRZtLWAWenZfL82l3KrneggHy7sG8+41AR6xgdrSV4bd6T2CIPah9fN3qk9QsuV9eA/KP3yS1dbkeOooHoqGfrMPAaUzuE+z/8RbxSSbUbwnP0yvnSeQXiAN8O6RHKWWgpIG6aETuQU0aiiJj4hR75J1V5XWejlb7v2x533tKtqWAtODurvQTlUfzBXuf/Mg2bZDlnuPyjo8JUjIyPdmiSZpsnqrBJmpWfz1aps8susBPl4cl6vWMalJnBaxwgseuN+yqqssbN0X3uEzQV1+ybVHqFlOt4+h6cKu8PJhtwyMnYXk76rmE9XZB5ynAFsnfQHfWghbd6xJHQqYybSyhyuqMm57c49uKjJkZgmrPof/PAQVBbC4Bth+D/At+Uv/SmY+jpVv/9OzpNPEXLe6IMKkRxU7j8sDO/kZPzT0g6uHBka2uJmtnYWVjArPZsvVmaxLb8Cb4sHZ6dEMS41gRHdorW8TgDw9/ZkeEo0w1NcvbfySqtZuKWgrv/d16tcTbL3tUc4o7Y9QpDaI7hFwdTXMZ0NW4SYTif5U18/5WbpTNMkp6Sa9F3FZOzeS8buYlZnlVBtc/3+RAR44+vpQbX94JYq8aF+SuZEDqAZOpFW4JiLmhxN/iaYfRfsWAAJA1w95eL6nrwX0EScVVUUvv0OBS+/fNA5z6ioQ1eOTE7GEhTkhmiPTUG5la9XZjMrI5uM3a4KboM7hDMuNYE/9IojxF9vwqXxTNNk057y2gQvnyXbiqiyudoj9EsK5YzOkQzrEklftUdoNierz2FrUG61syqzmIzdxWTscn3d14/R29ODnvHBpCaF0S85lNSkUBLD/PgiI5sHP1utok5yytKSS5FWZPa22UxZMYXcilxiA2K5vf/tjOkw5viKmhyNrQp+eR5+nQLe/jDynzDgmhbfU85RUsLeDz+k6L33XX3bDMM1w2ixEDRqFPFPPYmHf+urZFZhtfPDulxmpWezcEsBDqdJt9ggxqUmcGHfeOK1VE6ayJHbI0TUFVjpGKn2CHJiHE6TzXlldYlbxu5iNu0pw1n7drNDZAD9kkLrHt3jgvH2PPSHCirqJKcyJXQircTsbbN5bNFjVDuq645ZDAv+nv6U2cqOrajJ0Wz6wdVTrngn9LkcRj0BgdFN8CpOHnt+PkXvvsve/3yEs6ICv9MGU/37CkybrW5Ma9uDYnM4WbA5n1np2cxZt4cqm4OEUD8u7BfPuH4JpMS2/NlEaf3qt0dYuLmAXUWu9gjxIb6u5ZldohjaKULtEeSo8kqrSa9N3NJ37WV1ZgkVNa5ZtRA/r/3JW3Io/RJDCQtourYtIm2ZEjqRVmLUJ6PIqcg56LivxZdHhzzauKImR1OSBd/dD+u/gsiucP6L0GHYid3zJKvJzKTwrbco+fQzTLud4PNGE3H99ez97/8o/vRTqJfQtYZKcaZpsmLXXmalZzN7dQ5FFTWE+Hlxfp84xvVLIK1dmPaEiFvtKqxkwZZ8Fm529b8rrXZVe+0ZH8wZXSIZ1jmKtPZh2r95iquqcbAmu4T0XXvrlk9ml7g+kPT0MOgRH1yXwKUmh9E+wl8zviLHSUVRRFqBGkfNIZM5AKvDygWdLjixJ3DYYekb8NMkMB0w8lEY8nfwbLmfjlo3b6ZgxgxKZ38DHh6EjhtHxITr8G7XDoCqjIyGyRyAzUZVeroboj26LXnlfJGRxRcZ2ewqqsTH04NzesQwrl8CZ3WNOuwyI5Hmlhzhz1UR7bhqcDscTld11YWb81mwuYCZC7cz7edt+Hh6MKhDOEM772+P8OXKbC2Ja6OcTpNtBeW1hUtcjw25ZThq104mhvkxoH0419UmcD3jg5Xwi7iJZuhE3ODXrF+ZtHQSu8p2HfJ8XEAcP/zph+N/gl1LXUVP9qyBLqNcPeXC2h///U6yqowMCqbPoHzePAx/f8Iuu4zwa6/BKybG3aEdsz2l1Xy1MptZGVmsySrFw4ChnSMZ2y+B0T1jVGFQWp0Kq53fthfVNTjftKccgABvC9U2J4567yNUtKL1Kiy31iVu+x5ltTO1QT6e9K23761fciiRWo4rclJpyaVIC5Vbkctzy55jzs45tAtux4ikEfxnw38a7KHztfjy2OmPcX7H84/9CSqL4Md/wor3IDgBznsGul/QInvKmaZJxaJFFE6fQeXSpXiEhBA+fjxh46/CMyzM3eEdk9JqG9+tyeWLjCwWbS3ENKFPYghj+yVwQZ84ooMb0UZCpJXY1x7hoc/XNKhAuI+nh8HgjuHEBvsRF+JLTIgvccG+xIa4HuH+3lpi7GZWu4O12aV1hUvSd+9ld1EVABYPg5SYINeetyRX1clOUYH6mYk0My25FGlhbA4b7617j2mrpmGaJrel3sbVPa/G2+JNSnjKQVUujzmZM03I+BDmPAJVxTDkVjj7QfAJPDkv6ASYTidlP/5I4fQZVK9Zg2dUFNH33UfoZZdhCQxwd3iNZrU7mL8xny8ysvhxfR41diftIvz5+4gujO0XT6eolvd7L9IUooN9ubh/Inf/b+Uhz9udJpU1DhZtLSCvzFq3RG8fb4sH0cE+rmQv2Je4EF9iQ/yIrZf0RQf5qJ1CEzFNk52FlXVFSzJ2F7MupxSbw/VziQvxpV9SKH85rR39ksLolRCMv7feHoq0Jpqhk6a36n8w93EoyYSQRNferT6XuTsqt1mSs4SnljzFjtIdjEgawX2D7iMhsAmXI+Wth6/vgl2LIGmwq+hJbK+mu38TMW02Sr6eTeGMGdRs24ZXcjIRE64jZNw4PLxb7r6++pxOk992FPFFRhazV+VQWm0nIsCbC/rGM7ZfPP2SWl6TcpGTZegz88gqrjroeEKoH78+MAJwlbAvKLeSW1JNTkk1uSVV5JZaa79Wk1tSTW5pdV1D6X0MAyIDXUlf/URv36/jahNAP2/t2TpQSaWNjMz9ydvK3cXsrXTtPfb3ttAnMYR+SWG1hUtCidEKApEWSTN04j6r/gdf3ebqdwZQstv1PZxySd2eij08v/x5vtvxHYmBibw28jXOTDyz6Z6gpgJ+fhYWvwY+QXDhK9BvPHi0rE+1nVVVFH/6GYUz38KenYNPSgrxLzxP8OjRGJ6t45+g9TmlzMrI4quMbLJLqvH3tjCqRwxjUxM4o3OkZhLklHTv6JRDNn6+d3RK3fcWD4OYYNdMXN+kQ9/HNE1KqmyuhG9fklf7yCmtZmdhJUu2FdZV3qwvxM9rf8JXl+zVLvOsPRbi59VmP2ipsTvZkFvaoGH3toIKwJUUd40OYlSP2Lrlk11jgrBo6aRIm6MZOmlaL/VyJXEH8vSF1PEQFOfa2xVc+zUorkUuCzwRNqeND9d/yNSMqdiddib0nsC1va7F17MJPwXd8A18e5/r97rfeDj3cQiIaLr7NwFHaSl7P/wPRe+9h6OoCL/UVCJumEjgWWe1ijdXWcVVrgqV6dls3FOGxcPgzC6RjEtN4NweMVqSJELzNn6urLHXzejtm/HbU9rwa0G5lQPf1vh6eRAX4kdMsE/tV98Gyz3jQnyJCPRp8YmOaZpk7q1qULRkTVYJVrtrdjMqyKdey4BQ+iSGEuijf6dEWisVRRH3eSwUOMyfKb9wqCo6+LhPCATH1yZ58RAUX/v9vkcC+IW1yMIeB1qWu4xJSyexpXgLwxKG8eCgB0kKPszH0sejeBd8ez9s/AaiusMfX4J2Q5ru/k3AXlBA0bvvsfc//8FZXk7AsGFETrwev7S0Fp/IFVfWMHt1Dl+kZ/PbDtef1f7JoYxLTeD83nFqsizSwtkcTvLKapd0lljJKamqS/b2JYN7Sqvr9o/tY/EwiAnyqTez50dsiE/d3r64EF+ig33w8Wy+JZ5l1TZWZZbU7n1zJXAF5VYAfDw96J0QQmpyqGv5ZHIo8SG+Lf7fWBFpPC25FPcJiIKKvIOPhyTBnWtcSzFLs6Esx/W17pHlOpa3Hsr3gNlwPwWevrWze7VJXt1MX73ELzAGPNyzn6KgqoDnlz/P7G2ziQ+I5+XhL3N20tlN95+rwwaLX4Wfn3N9f86/YMgtYGk5JfBrMrMomjmT4k8/xaypIWj0aCKun4Bfz57uDu2Iqm0Ofly/h1np2fy8KQ+bw6RTVAB3n9uVsf0SSI7wd3eIItJIXhYPEkL9SAj1O+wYp9OkqLJm/76+0uq6BDC3tIoNuWXM35hPZc3BFTwjArwbLO9ssKevNgE80qzY4WY07Q4nm/aUNyhcsiW/vG62sVNUAGd1jaJfsqvqZEpskJZ6i0gdzdBJ0zFNeHUgFG5ueNzLDy54ufF76Bx2V1JXmg1l2Q0Tv7IcV/JXmg2OmobXGR4QGFtvti/hgCWetbN/Xk239NHutPPRho94LeM1rA4r1/a6lgm9J+Dnefg3E8ds5yJX0ZP89ZByPox5BkKTm+7+J8i6ZQuFM2ZQ8vVs8PAg5MILiLhuAj4dO7g7tMNyOE0WbS1gVno236/NpdxqJzrIhwv7xjMuNYGe8cH6pFvkFGaaJmVWO3saJH0HL/Msqqg56NpAH8+D9/QF+7KjsIL3F++sWyIJrhYPyeH+5JRU1+1FDA/w3t/vLSmUvomhhPi3nA/vRKR5aIZO3GPrPFcy1/cK2LHw+KtcWjwhJMH1OBzTdPVc2zezty/JK639dcFm2PYzWEsPvtYv/OAkr34SGBwPPsFHXeKZnpfOk0ueZNPeTZwefzoPDnqQ9iHtG/86j6aiAOY8ChkfQEgyXPERpIxpuvufoKpVqyiYPp3yH+di+PkRPv4qwq+5Bq+4OHeHdkimabI6q4RZ6dl8tSqb/DIrQT6ejOkVy7jUBE7rGNHi99CISPMwDINgXy+Cfb3oEhN02HHVNgd76lXrPDDpW7i5gLyyapyH+ezc7jTZvbeSqwa3IzU5lNSkMJLC/fSBkogcE83QSdMwTZgxHCoK4e+/g2cLKUNvLduf5NUlfjkNl3lW5B98nVfAIWb6XPv5Cn0DeHHHl3y58wdi/GO4f9D9nJN8TtP9B+x0Qvr7rgbh1jJXT7mz7gNv9/doM02TyiVLKJg+ncrFS/AIDiZ8/FWE/eUvLbYZ+M7CCmalZ/PFyiy25VfgbfHg7JQoxqUmMKJbNL5eKnsuIieP3eGkoLyGIU/PPeQOcwPY/swx9h4VkTZPM3TS/DZ8DdnpMHZqy0nmwFXOPyoIoroefozdCmW5DZO8+ss8dyyEshwcTjsfBwXyclgoVR4Gfyut4IYi8C+dDMEfHJD47dvXF3v034/6ffsCo13J5N5t0G4onP8CRHdv2t+T42A6nZTPm0fB9BlUr1qFJSqS6HvvIfTPf8YS2PKqlBaUW/l6ZTazMrLJ2F0MwOAO4Vw/rCN/6BWn5Usi0mw8LR7EhvgSH+p3yL598UfY7yci0hhK6OTEOR0w7ymI6AJ9/uzuaI6dpw+EtXM9DmPVngyeXPI464s3Mzi4E/+IHEJHa9X+pC9nFWz8DuwH/2dNQHTDJK/+vr6cVfDTpP3Xle9xfR1wrauCpZuX3Zg2G6XffEPBjBnUbNmKV2IisY/9k5CLLsLDxz0VHw9XVKDCaueHdbnMSs9m4ZYCHE6TbrFBPDCmGxf2jdebJhFxq8b07RMROR5K6OTErf7EVbDjT2+79r+1IXur9zJlxRQ+3fwp0X7RTD5zMqPbjz708krThOrig5d07lvmuXenq8BJdfHRn3jLj25N5pzV1RR/+ilFb83Elp2NT5cuxE+eTPCY89zaDHxWelaDN0RZxVXc98kq3lu0g/W5ZVTZHCSE+jHxzI6M65dASuzh976IiDSnff35mqtvn4icOrSHTk6MwwavprmWNk78BTzaRhllp+nk082fMmXFFMpryhnffTw39buJAK8m2MdWU7l/Wee7fzzMIAMea0Ti18QcZWXs/c9HFL37Lo7CQvz69iXihhsIPPssjBbwsx36zLxDLlkyDLhiUDLj+iWQ1i4MDxU3ERERkVZMe+ik+aS/D3t3wJX/azPJ3NqCtTy55EnWFK5hQMwAHhr8EF3CujTdE3j7Q0Qn1yMkCUp2HzwmJLHpnq8R7IWFFL33Pns//BBnWRkBQ4cSMXEi/oMGuq3amrO2+tv6nFLW5ZSxPqf0kMkcACZMuqh38wYoIiIi0gIooZPjZ6uCnydD0mDoMsrd0ZywEmsJL694mY83fUy4bzhPD3ua8zucf3ITmpGPwle3uX4v9/Hycx1vBrbsbApnvk3xJ59gWq0EnXsuERMn4tereZuBV1jtbMh1JW3rc0rZkFvGhpxSKmob+3oY0CEyAD8vD6pszoOu1/44EREROVUpoZPjt+wtV+Pvi6e7vXjHiXCaTr7Y8gUv/f4SJTUlXNX9Km7udzNB3s2w/2pff759VS6Pp2/fcbBu20bhjDcp+eorAEIuuICI6yfg07HjSX1e0zTJ3FvVIHlbn1PKzqJK9q3+DvL1pHtsMH8akEj3uGC6xwXTNSYIP2/LQXvoQEUFRERE5NSmhE6Oj7UMFr4IHYdDh2Hujua4bSjawJNLnmRl/kr6RfXj4dMeJiW8mZODPped9ARun6o1aymcPp2yOXMwfHwIu+IKIq69Bq/4+CZ/rmqbg40NErcy1ueWUlZtrxvTPsKf7nHBXNzflbx1iw0iMezwTXVVVEBERESkISV0cnyWvA6VhTDiEXdHclxKa0p5Lf01Ptr4EaE+oTw59Eku6HQBHkbb2AdYn2maVP62jMJp06hYtAiPoCAibphI+F//imd4eJPcP7e0en/SVpvAbS+owFk76xbgbSElNogL+8bXzbp1iw0iwOfY/wkal5qgBE5ERESkVqPeTRmGcR4wBbAAb5qm+cwB5+8CJgB2IB/4m2maO2vPOYDVtUN3maZ5YRPFLu5SWQSLXoFuf4TEAe6O5piYpsnX277mheUvsNe6l8u6XsatqbcS4hPi7tCanOl0Uj5/PoXTplO1ciWWyEii7r6LsCuuOO5m4Fa7g817yhsmb7mlFFfa6sYkhvnRPS6Y8/vE0yMuiO5xwSSF+avypIiIiMhJcNSEzjAMC/AacC6QCSwzDONL0zTX1RuWDqSZpllpGMZNwHPAvg7TVaZp9mviuMWdfp3iWnI5/CF3R3JMNu3dxFNLnmJF3gr6RPZh6jlT6RHRw91hNTnTbqf0228pnD4D6+bNeCUkEPPoI4RefDEevr6Nvk9eWXWDGbf1OaVsza/AUTvt5uvlQUpsMGN6xdbOuAXTLS6IYF+vk/XSREREROQAjZmhGwRsMU1zG4BhGB8BY4G6hM40zZ/qjV8CjG/KIKUFKdsDS6dB70shpnUkQ+U15UxdOZUP139IkHcQjw15jIu6XNTmllc6rVZKPv+cwjffwpaZiXfnTsQ/9yzBY8ZgeB0+ybI5nGzJK2dDbsMlkwXlNXVj4kN86RYXzLk9YuqWTLaPCMCiWTcRERERt2pMQpcA1G+UlQkMPsL464Bv633vaxjGclzLMZ8xTXPWgRcYhjERmAiQnJzciJDEbRY8D44aOPsBd0dyVKZp8u32b3l++fMUVBVwSddLuD31dkJ9Q90dWpNylFdQ/N+PKHznHRz5Bfj26UPMgw8QOHz4Qc3Aiypq6hK2dbXLJrfklWFzuGbdvD096BoTyPCU6LrErXtcEKH+3u54aSIiIiJyFI1J6A71Ebx5yIGGMR5IA86qdzjZNM1swzA6AvMMw1htmubWBjczzenAdIC0tLRD3ltagOJdsPxt6P8XV1PsFmxr8VYmLZ3Eb7m/0SOiB1OGT6F3VNtqPG3fu5ei995j7wcf4iwtJeD0IURMnoz/4ME4nCZb8ivqkjZXb7dS9pRa666PDvKhe1wwZ3WNonvtXreOkQF4WtrWzKWIiIhIW9aYhC4TSKr3fSKQfeAgwzDOAR4CzjJNs+5do2ma2bVftxmGMR9IBbYeeL20AvOfBcMDzrzP3ZEcVqWtkjdWvsH7697H38ufR057hEu6XILFw+Lu0JqMLSeHwrffpvjjTzCrqvAdPpKCsZezJCiB9ZmlrF/2K5v2lGG1uxpwe1kMOkUFMrRTZINZt4hAHze/EhERERE5UY1J6JYBXQzD6ABkAZcDV9YfYBhGKjANOM80zbx6x8OAStM0rYaPCQhQAAAgAElEQVRhRAJDcRVMkdamYDOs/BAG3wQhLa9kvGma/LDzB55b9hx5lXlc1Pki7hhwB+G+J16W/2SblZ7VqL5qVdu2s+u1N3B89w2m6WR9jyH8p9PZ/G6EwfwSoISIAG+6xwXz1yHt6pK3TlGBeHtq1k1ERESkLTpqQmeapt0wjFuB73G1LZhpmuZawzAeB5abpvklMBkIBD6ubQi8rz1Bd2CaYRhOwAPXHrp1h3wiadl+ego8/eCMO90dyUG2l2zn6aVPszhnMd3Cu/HCWS/QL7p1FFadlZ7Fg5+tpsrmACCruIoHP1tNtc1Op+gg1ueUsmf5Stp9/zE9t6zA5mHh+3aD+TzlbILbJdE9LphzYl0zbj3igokK8jlsU24RERERaXsM02xZW9bS0tLM5cuXuzsMqS9nFUwbBmfeCyMednc0dSptlcxYPYN31r6Dn8WPW1Nv5bKUy/D0OPZm1e4y9Jl5ZBVXHXzCNOlVuI0/b5pHWt5Gqr392H7GeXDJ5XTt1o7O0YH4erWdZaQiIiIisp9hGL+bppnWmLGt552vuM+8J8E3BIbc6u5IANfyynm75/Hsb8+SU5HDBR0v4K60u4j0i3R3aI1SYbWzbEcRi7cW1iVzYdWlPLDs/3gm7Sq6lGRx2aZ59CzagREWRuSddxB25ZWkBgW5OXIRERERaWmU0MmR7VoKm7+Hkf8EP/eX+99Vuounf3uahVkL6RzambdHv01abKM+vHAbq91B+q5iFm0tZNGWAjJ2F2N3mnhZDLwtHtQ4nFy14Qd6FW7j9XkvEGKrpDAgjJhHHib0kkuOqRm4iIiIiJxalNDJ4ZkmzHsCAqJh8A1uDaXaXs1ba95i5uqZeFm8uDftXq7ofgVeHodvmO0udoeTNdml/LqlgMVbC1m2owir3YmHAb0TQ7l+WAfOCLLRrWIP6xb8zo4lvzEgdz0GEGSr5M1+FzHs7hsIH9jO3S9FRERERFo4JXRyeNvmw44FMOY58A5wWxg/7/6Zp397mqzyLMZ0GMM9afcQ7R/ttngO5HSabNxTxqKthSzeWsDSbUWUWe0A9I7w4dY4KwPshSTuzcK5eBPWdzbhLCsjD4g0DMJ8/TFxNXx0eFi4JMrB6UrmRERERKQRlNDJoZkmzH0cQpJgwDVuCSGzLJNnf3uW+Znz6RjSkbdGvcWguEFuiaU+0zTZUVjJoq0FLNpayJKthRSWW4msLuE0ZyEPGHvpWpZLSPYOHLt3gdPVD67K3x+flBSC/3g+vind8O2WgiU0jG1jx7KvNJGX00H4L99jz78Hz6go971IEREREWkVlNDJoW38BrJXwIWvgmfzNqC2Oqy8veZt3lz9Jh6GB3cNuIvx3cfjZXHf8sqckioWbSlk0dZClm3KwStzJx1LsulVncfF1XlE5+/Gs7ysbrxXYiI+3VLw/eP5rq8pKXglJmJ4NOwHl/PYvzBrE759TKeT/KmvE/fPR5vltYmIiIhI66WETg7mdLgqW0Z0hr5XNOtTL8xayNNLn2ZX2S5GtRvFvQPvJTYgtlljACgst7JkayHpGVvITl+D/+5tdCzJZnRZDn8rzcPDdCVhhq8vPl274pt2nitx69YNn5QULIGBjXqeqowMsNkaHrTZqEpPb+qXJCIiIiJtkBI6OdiazyBvHfxpJlia549ITnkOzy17jh93/Uj74PZMO3cap8ef3izPDVBaVkn6wgy2L82gcv0GQrJ30LEkm0tqKurGmNExBKZ2x7fb2LrEzTs5GcNy/P3gOs76vCnCFxEREZFTlBI6achhg/mTIKY39LjopD+dzWHj3XXvMn3VdEzT5Pb+t/PXHn/F2+J90p7TXlRE2Zp1bF2SQdHqtVi2byWqMJto00E0YLd4UpnQHv/+w4lM7YV/9+74pnTFEur+tg0iIiIiIvUpoZOGMj6Aom1wxX/hgP1eTW1x9mImLZ3EjtIdjEweyX0D7yM+ML7J7m/a7dTs2EH1ho1Url9Pwcq1ODZvwqekCIAAoNo3mMKYZKr6DSQ2tTddh/YnqHNHDE/91RARERGRlk/vWmU/WzX8/BwkDoSuo0/a0+RW5PL88uf5fsf3JAUlMXXkVIYlDjuhezpKSqjesBHrxg1Ub9hI9YYNVG/egmGrAcDmYWFXYAzbQzpQ1WskYb170OX0/qT17Uigj/4aiIiIiEjrpHeyst/ymVCaBRe9AYbR5Le3OW18sO4Dpq6citN0cku/W7i217X4WBpfRdN0OKjZucuVuG3ciHXDRqo3bsSek1M3ptI/iC1BcWxuN4RtwfHYO3SiY/8enJYSy/gOEYQFnLzlnCIiIiIizUkJnbhYy2HBC9DhLOhwZpPfflnuMp5a8hRbS7ZyVuJZ3D/ofpKCko54jaO8HOtG12zbvsTNunkzZlWVa4DFQnVsIrsjO/B73CBW+0SzPSQO/9gYhnaO4PROkUzsFEF0sG+Tvx4RERERkZZACZ24LH0dKgtg5In3Ppu9bTZTVkwhtyKXKP8o4vzjWFmwkoTABF4Z8QpnJ53dYLzpdGLLzNyfuG1yzbzZMjPrxlhCQjA6d6Xo7DGs9Y1mviOE38xQbBYvIgN9OL1TBH+uTeKSwv1P+DWIiIiIiLQGSugEqvbCr69Ayh8gMe2EbjV722weW/QYviVV/HOWg5fG7WFlYB4jkkbwzJnP4GN1UpWR4drnttGVwFk3bsRZWem6gYcH3u3a4du7F75jL2JrcByLCWdugcnmfFcLgWAfT4Z0iuDhTpGc3imCztGBGCdhiaiIiIiISEunhE7g15fBWgrDHzrhW01ZMYVqRzVXLXTQbTfcNNvB5gQPUooWkPXsOGy7doNpAuARGIhPtxRCLroIn24pmB27sMornMWZFfy6tYC12aWYWeDnVcWgDuH8KS2J0ztF0iM+GIuHEjgRERERESV0p7ryPFj6BvS6BGJ7nfDtcity6bHDyah0MID+26D/Nic5YVX4DuxGyIUX1jbl7oYzJoaM3SUs2lLAoq2FZKRnY3dm4W3xIDU5lDtGduX0zhH0TQzF2/PktlAQEREREWmNlNCd6ha8AHYrDP/HCd+qsKqQ0CoP7vvUVnfM7gHze8NXlybxzUUvsTqrhEVbC1n8XSbLdqzCanfiYUDvxFCuP7MjQztFMqBdGH7elhOOR0RERESkrVNCdyor3u1qVZB6FUR0OqFblVhLuPG767nzYyt+Na7ZOQBPJwxbCz8MPIPUx+dQZrUD0C02iKsGt+P0ThEM6hhOsK/XCb4YEREREZFTjxK6U9nPz7q+nnX/Cd2mrKaMiXMmMvTTzXTLArth4Fm7Tw7AcHpw5tyd9J54Ead3iuC0jhFEBja+95yIiIiIiByaErpTVcEWyPgQBk2EkMTjvk2FrYKbfryJ+HnrGL3cTrF3AKE1FQ3GeDuddC/cwR8v6n2iUYuIiIiISD1K6E5V8yeBpy8Mu+u4b1Flr+LWubdizVjF9T+Y+A8dyp9ix1HhOLgCZUKoH388kXhFREREROQgKh14KspdDWs+hdNuhMDo47qF1WHljp/uYMfm5Tz6lS/eCQn897yJVDgMPA9oKeDnZeHe0SlNEbmIiIiIiNSjhO5UNO8p8A2B0/9+XJfbHDbunn83y3b+ygvfx+Bd42TZdf9g6u/5XD2kHZP/1IeEUD8MXDNzT1/cm3GpCU37GkREREREREsuTzm7l8Gmb2HEI+AXdsyX25127l9wPz/vns+0ZT3w27qG7Pue4B/p5YzuGcOjF/TE4mFwUf/j35cnIiIiIiKNoxm6U828xyEgCgbfeMyXOpwOHlr4EHN2zuGFrDMJ+3k11quv54at/qQmhTLl8lQsHgfvnxMRERERkZNDCd2pZNt82P4LDLsbfAKP6VKn6eRfi//FN9u/4Z/GhST933yM4edwdXUPEkP9ePPqgfh6qRm4iIiIiEhzUkJ3qjBNmPsEBCfAgGuP8VKTSUsn8fmWz7kr6s/0fmUOli5duSn+D3h5evDOtYMID/A+SYGLiIiIiMjhKKE7VWz6DrKWu5qIe/k2+jLTNJm8fDL/3fhfru9wFWe+sgg8PXl88DXssRnMvGYgyRH+JzFwERERERE5HCV0pwKnE+Y9CeEdod+Vx3TpK+mv8P6697my6+WM+7/t1OzezXvn3cjiCm9eu7I/fRJDT1LQIiIiIiJyNEroTgVrP4M9a2D4Q2DxavRl01ZOY8bqGVzS5RL+tsiXil9+4dcxV/NBVQRPjevF8G7H18NORERERESahhK6ts5hh58mQXRP6Hlxoy97Z807vJrxKhd0vIA7igZQNONNdg0dzZOW7tw2sguXD0o+iUGLiIiIiEhjNCqhMwzjPMMwNhqGscUwjAcOcf4uwzDWGYaxyjCMuYZhtKt37mrDMDbXPq5uyuClEVZ+CEVbYcTD4NG4/P3D9R/ywu8vMLr9aP4Rdjm5Dz9KeUovbokYzqUDErnznC4nOWgREREREWmMo77DNwzDArwGjAF6AFcYhtHjgGHpQJppmn2AT4Dnaq8NB/4JDAYGAf80DOPYu1nL8bFbYf6zkDAAUsY06pJPNn3C0789zfCk4TzR/R5ybr0de2AwN3T6E6d3i2PSxb0xDPWaExERERFpCRozZTMI2GKa5jbTNGuAj4Cx9QeYpvmTaZqVtd8uARJrfz0amGOaZpFpmnuBOcB5TRO6HNXyt6E0E0Y+Co1Iwr7a+hWPL36coQlDmTzkafbccTe2vXu5r99fiGsfz9Sr+uNl0SpdEREREZGWojHvzhOA3fW+z6w9djjXAd8ey7WGYUw0DGO5YRjL8/PzGxGSHFVNBSx4HtoPg45nH3X4dzu+4+FfH2ZQ7CBeOusliiY9S9WKFbw28ApKEjvy9jUDCfTxPOlhi4iIiIhI4zUmoTvU1I55yIGGMR5IAyYfy7WmaU43TTPNNM20qKioRoQkR7X0DajId83OHcW8XfN48JcH6RfVj5dHvEzVx59T/PHHfNd3NAuTUnn3b4OIDm587zoREREREWkejUnoMoGket8nAtkHDjIM4xzgIeBC0zStx3KtNLGqYvh1CnQ9D5IGHXHowqyF3PPzPXSP6M5rI1/DXLGGPZOeZkP7PrzR+VzevDqNztGBzRS4iIiIiIgci8YkdMuALoZhdDAMwxu4HPiy/gDDMFKBabiSubx6p74HRhmGEVZbDGVU7TE5mRa9AtUlrsqWR7A0Zyl3/HQHnUM78/o5r+OdV0LWHXdQGBLNw70u5d+X92dg+/BmClpERERERI7VUTdFmaZpNwzjVlyJmAWYaZrmWsMwHgeWm6b5Ja4lloHAx7UVEHeZpnmhaZpFhmE8gSspBHjcNM2ik/JKxKU8H5a87uo5F9v7sMNW7FnB3+f9naSgJKadO40ghxc7brmFqior958xkXsuGsCY3nHNGLiIiIiIiByrRlW5ME3zG+CbA449Wu/X5xzh2pnAzOMNUI7RwhfBXg3DHzrskNX5q7l57s3E+McwY9QMQn1CybrjTqo3beZfp13HH8YM4tqhHZoxaBEREREROR6qQd+WlGTCsjeh3xUQ2fmQQ9YXrueGH28gzCeMN0e9SaRfJIVvvEHZ99/zVo8/EH/u2Tw4pnszBy4iIiIiIsdDdejbkp+fc3096/5Dnt68dzMT50wk0CuQt0a/RUxADGVz55I/5WV+Sh5A5rkX8d5lffHwUONwEREREZHWQAldW1G4FdL/DwZOgNDkg07vKNnB9T9cj5eHF2+OepP4wHismzeTec99bAlL4utzruY/fx2Ij6fFDcGLiIiIiMjxUELXVsx/Gjx9YNjdB53aXbab6364DhOTN0e/SXJwMo7iYnbcdDMlpoVXh1/PzIlnEOLv5YbARURERETkeGkPXVuwZy2s/gQG3wBBMQ1O5ZTnMOH7CVgdVmaMmkHHkI6Ydjs777iLmuxcnhv6N166dTQJoX5uCl5ERERERI6XErq2YN5T4BMMp9/W4HBeZR4TfphAWU0Z086dRtewrgDkPDcZ65LFvNbvYu6640/0iA92R9QiIiIiInKClNC1dpnLYeNsOP3v4L+/CXhhVSETfphAQVUBr5/7Oj0jegKw97PPKXnvPWZ1PINR91zPGV0i3RW5iIiIiIicIO2ha+3mPQH+kXDajXWHiquLuX7O9eSU5/D6Oa/TN6ovAFUrV5L16D9ZHdmZkLvu5uL+ie6KWkREREREmoBm6Fqz7b/Atvkw7C7wCQKgtKaUG368gZ0lO3l5xMukxaYBYNuTx6YbbibPO4hNNz7ITSNT3Bi4iIiIiIg0BSV0rZVpwtwnIDgB0q4DoMJWwc0/3symvZt4afhLDIkfAoDTamXthBtwlJXzwxV389AVp2EY6jUnIiIiItLaKaFrrTb/AJm/wZn3gpcvVfYqbpl7C2sK1vD8mc9zZuKZAJimydp7/oHP5g18MnoCj95+IZ4W/dhFRERERNoC7aFrjZxO1+xcWAdIHY/VYeX2ebeTnpfOM8OeYWS7kXVDN0+dgeecb/gq9Xzuenwi/t76kYuIiIiItBV6d98arZsFe1bDxTOwAXfNv4vFOYt5cuiTjOkwpm5Y1o/zsb36b35P6sOlU/5JZKCP+2IWEREREZEmp4SutXHY4aenILoH9h5jue+X+/gl8xceOe0RxnYeWzesZMs2cu++m/ygGHq/+iIdooPcGLSIiIiIiJwMSuham1UfQeEWHJe9zz8WPcKPu37k/oH3c1nKZXVDrCWlrLr6eryd4PPMi6SmJLgxYBEREREROVlUHaM1sVth/jM441N5rGgZ327/ljv638H4HuPrhjgdDn6+5hbCinLJvetRho9IdWPAIiIiIiJyMimha01+fxezZDeT2nVj1tZZ3NT3Jq7rfV2DId/e8wRJ65ez/uK/MfbasYe5kYiIiIiItAVK6FqLmgrMXybzXPue/Df3V/7W62/c1PemBkO+f+0DOn77Xzamns0lT9zppkBFRERERKS5KKFrJcyl03jZ28r/GWWM7z6eO/rf0aA5+K/fLyZ66nNkxndmzFsv4eGhH62IiIiISFund/2tQVUx01a+zpuhIVza9VLuG3hfg2Ruzdod2B+8m2pffwa+Ow0ff183BisiIiIiIs1FVS5bgbe/v5XXgnwZG38mD5/2cINkbnd+CZtu/judq8sIf+sdQpPi3RipiIiIiIg0J83QtXAfrJzOiyUrGWMJ418jX8bD2P8jK66s4Zsb7qP7ni14P/gIiUMGuDFSERERERFpbkroWrCPN33MMxmvMLKiiqfOfQOLh6XuXLXNwRv3vsCZ637BeskVdPvLZUe4k4iIiIiItEVK6FqoL7d+yROLn2BYlZXJcefiFdOj7pzTaTL5+f/yh3kfUNFvIH0ff8iNkYqIiIiIiLsooWuBvtv+HY/8+giDPcN4Ka8Ir7MfaHD+xQ9+YeRHL2GPiiF12isYFsth7iQiIiIiIm2ZEroWZu6uuTyw4AH6hXVjyra1+Ay4BsLa1Z2f+eM6ur76BAGGkx5vT8cSEuK+YEVERERExK1U5bIFWZC5gHt+voeekT2ZWuWLv+EJZ95Td/7rlVlYn36CziXZJEx9Dd9OndwYrYiIiIiIuJtm6FqIJTlLuHP+nXQJ7cLrfe4gYPWnMHgiBMUCsHRbIQufeImzszIIv/02QkYMd3PEIiIiIiLibkroWoDf9/zObfNuIzk4mennTid44b/BJwiG3gHA5j1lTH3mXf6y5ht8R40m5sYb3ByxiIiIiIi0BEro3GxV/ipumXsLsQGxTD93OqGFW2HD1zDkVvAPZ09pNQ+89BW3LX4fz65daffs0w0ai4uIiIiIyKlLe+jcaH3hem788UbCfcOZce4MIv0iYd714B8BQ26mrNrGjW/8zC1z38AvwI+Ob0zFw8/P3WGLiIiIiEgLoRk6N9m8dzMT50wk0CuQN0e9SUxADOxYCFvnwRl3YvMM4Jb3l3Px7DeIryyi/asv4xUf7+6wRURERESkBWlUQmcYxnmGYWw0DGOLYRgPHOL8mYZhrDAMw24Yxp8OOOcwDCOj9vFlUwXemm0v2c6EHybg7eHNW6PeIj4wHkwT5j4BQXGYaddx/6er6Pzle6Tt2UDcI4/gn5bm7rBFRERERKSFOeqSS8MwLMBrwLlAJrDMMIwvTdNcV2/YLuAa4J6D70CVaZr9miDWNmF36W4mfD8BgBmjZ5AUnOQ6sXkO7F4C57/Ii/N3s/eLr7h+83xCr7icsMv/7MaIRURERESkpWrMHrpBwBbTNLcBGIbxETAWqEvoTNPcUXvOeRJibDNyynO47ofrqHHWMHP0TDqGdHSdcDph3hMQ1p6P7Gfz3adzeHHlx/ilpRH74IPuDVpERERERFqsxiy5TAB21/s+s/ZYY/kahrHcMIwlhmGMO9QAwzAm1o5Znp+ffwy3bj3yKvO47ofrKK8pZ9q50+gS1mX/yfVfQO4q1na9mcn/+42nfn8P36hIEl+eguHt7b6gRURERESkRWtMQneoGvnmMTxHsmmaacCVwL8Nw+h00M1Mc7ppmmmmaaZFRUUdw61bh8KqQib8MIHCqkLeOPcNekT02H/SYYefJlEd2oUrF8TxZPoHBNurSJr6Gp7h4e4LWkREREREWrzGJHSZQFK97xOB7MY+gWma2bVftwHzgdRjiK/VK64u5vo515NbkcvUc6bSJ6pPwwGr/gsFm3i45EJuWfMF7XO3Ev/0JHy7d3dPwCIiIiIi0mo0JqFbBnQxDKODYRjewOVAo6pVGoYRZhiGT+2vI4Gh1Nt719aV1pQycc5Edpbs5OURLzMgZkDDAXYrjp+eZqNHJyybahi2aRERN95A8Jgx7glYRERERERalaMmdKZp2oFbge+B9cD/TNNcaxjG44ZhXAhgGMZAwzAygUuBaYZhrK29vDuw3DCMlcBPwDMHVMdssypsFdz0401sLt7Mv4f/m9PiTjtoTM1v72Ap3c1/soZxdfosAocPJ+q229wQrYiIiIiItEaGaR7LdriTLy0tzVy+fLm7wzghVfYqbvrxJjLyMnjh7BcYmTzyoDEOawVlz/Vi095I/Bd44BcdRfv/foQlMNANEYuIiIiISEthGMbvtXVIjqpRjcWl8awOK7fNu430vHSeGfbMIZM50zSZ884TBFfvxSc9AC8Dkl57VcmciIiIiIgcEyV0TcjmsHHnT3eyNGcpTwx9gvM6nHfIcTPnrmRQ1vtsWtEJ7z35JLz4It7t2zdvsCIiIiIi0uopoWsiNqeNe3+5lwVZC3hkyCNc2OnCQ46blZ5F+fwpONaBub2S6HvvJfCMoc0crYiIiIiItAWe7g6gLXA4HTy04CHm7prLA4Me4NKulx5y3K9bCpj0yQK+yfuR/DXBhIy9kPBrrm7maEVEREREpK1QQneCnKaTRxc9yrc7vuWuAXdxVferDjlufU4pN77/O5NqPqVwsT++3bsQ+/jjGMah+raLiIiIiIgcnZZcngDTNHlyyZN8ufVLbu53M9f2uvaQ47KLq7j27WX0MHPo/tNKPPx8SXxjBh4+Ps0csYiIiIiItCWaoTtOpmny3LLn+HjTx0zoPYEb+9x4yHElVTauefs3qqqsTPp9OrZKD9pNewavmJhmjlhERERERNoaJXTHwTRN/r3i3/zf+v9jfPfx3JZ62yGXTlrtDm54fznbCyr4tGIONdv2EvfnPvgNG+OGqEVEREREpK3Rksvj8MbKN5i5ZiZ/Tvkz9w2875DJnNNpcs/Hq1iyrYhpkTl4ffcdYd2qCb17ihsiFhERERGRtkgJ3TF6a/VbTF05lXGdx/GPwf84bFGTZ7/bwFcrs3mqq0n8zH/jH2Ml5oYrITiumSMWEREREZG2Sksuj2L2ttlMWTGF3IpcgryDKK0pZUyHMTw25DE8jEPnw+/8up1pv2xjYvdABs54GI9ACwln1WCcdXczRy8iIiIiIm2ZErojmL1tNo8teoxqRzUApTWleBgenBF/BhYPyyGv+W5NLv/6eh1juoRx+df/xlZRTtLZu/EccS/4hzdn+CIiIiIi0sZpyeURTFkxpS6Z28dpOnk149VDjv99ZxG3f5ROv8QQHlz/OdbVq4n/YxQ+scFw2s3NEbKIiIiIiJxClNAdQW5FbqOPb80v57p3lxMf6sfLlvVUfP01kX8dR5BlKZxxJ/gGn+xwRURERETkFKOE7ghiA2IbdTyvrJqrZ/6GxTB4q4ed8pf/TdCoUUTGrIDAWBh0fXOEKyIiIiIipxgldEdwe//b8bX4Njjma/Hl9v63131fYbVz3TvLKSyvYeY5sdgeewifLl2InzAKY/cSOOte8PJr7tBFREREROQUoKIoR3B+x/MB6qpcxgbEcnv/2+uO2xxObvlwBWuzS3jr0u4EPnIbDg8PEl99BY9vroLQZEj9qztfgoiIiIiItGFK6I7i/I7n1yVw9ZmmycOfr2H+xnwmje1J5+nPUr5jB8lvvYV32QrIWQnj3gBPbzdELSIiIiIipwIldMfp5blb+O/y3fx9RGfOWTKLwvnziXnkYQIGpcHUIRCZAn0uc3eYIiIiIiLShmkP3XH43/LdvPTjJi7pn8gE21YKp00j9NI/EXbllbDqf1CwEUY8BIfpVSciIiIiItIUNEN3jOZvzOPBz1YzrEsk/+rhSeb4h/BLTSXmkUcwHDaY/zTE9YXuF7o7VBERERERaeOU0B3FrPQsJn+/keziKiKDfCiurCElJohXxrQjZ/yVWEJDSXzlZTy8vWHZm1C8E85/EQzD3aGLiIiIiEgbp4TuCGalZ/HgZ6upsjkAyC+zYgCXp8ZQfN89OAqLaPfBB3hGRoKtCn6eDMlDoPNI9wYuIiIiIiKnBCV0RzD5+411ydw+JlDxwmSqNv5O/OTJ+PXq6Trx2wwoz4VL39bsnIiIiIiINAsVRTmC7OKqg479Yfsizt64kIgJ1xFywR9dB5eRbqgAABSQSURBVKtLYeFL0GkktDu9maMUEREREZFTlRK6I4gP9QMgrLqUZxdMZUj2am5aNYvVCT2IuvPO/QOXTIWqIhjxsJsiFRERERGRU5ESuiO4d3QKfl4Wrtwwh16F27l/+QfsCYjA91+TMCy1LQkqi2DRq9D9Akjo796ARURERETklKI9dEcwLjUBy95Ckj9bhgcm3k479rsf4sIzUvYPWvgS1JTD8IfcF6iIiIiIiJySlNAdRdovn1OMCYBhsdB301JgtOtkaY6rGEqfP0N0d/cFKXIAm81GZmYm1dXV7g5FREROMb6+viQmJuLl5eXuUEROCUrojsCWl0fJ55+Do7bSpcNByWefEXXzTXhGRcGC58Fpg7MfcG+gIgfIzMwkKCiI9u3bY6jqqoiINBPTNCksLCQzM5MOHTq4OxyRU4L20B1BwdTXMZ3OBsdMp5P8qa/D3h3w+7vQ/68Qrn+wpGWprq4mIiJCyZyIiDQrwzCIiIjQChGRZqQZuiOoysgAm63hQZuNqvR0mJ8DHhY48173BCdyFErmRETEHfT/j0jzalRCZxjGecAUwAK8aZrmMwecPxP4N9AHuNw0zU/qnbsa2FfP/0nTNN9tisCbQ8dZnx/6RP5GmHoanHYzBMc3b1AiIiIiIiK1jrrk0jAMC/AaMIb/b+/eo6Os7zyOv78JlAQUsYIWCDZxoVyThossEOEg1aBFMLjWWkHF4xEOKleLxZ6jRBcqULBdilRYF4GjK0sREMEteLisDfUUEhPDJSgXKQSC3AySNALB3/4xQ5qEXAYyw5MZPq9zcmbml+fynfyemTzf53d5oBPwCzPrVGmxg8AI4L8rrft9YArwr0BPYIqZ3Vj3sD22aRo0bAx3TPQ6EpGgWJV9mJTpG0mYvJaU6RtZlX3Y65CkOrnL4HddIL2Z7zF3mdcRyWVau38tqctTSVqcROryVNbuX+t1SHIFzh87xoHhj1J6/HhQtnfgwAG6dOkSlG1VtnnzZu677z4AVq9ezfTp02tZo3rx8fEkJiaSnJxMjx49ghWiiNRBIGPoegJ7nXP7nXPngKXA/eUXcM4dcM7lAt9VWncg8JFz7pRz7mvgI+CeIMTtnSM5sOt96P0MNLnJ62hE6mxV9mFeWLGdw4UlOOBwYQkvrNge8qTupz/9KYWFhRQWFjJv3ryy8vInHvVJeno6rVu3Jjk5meTkZD788MOrH0TuMvhgLJw+BDjf4wdjQ57UhVtd/elPf6Jz585ERUWRmZlZ4Xevvvoqbdu2pX379qxbt+6qx7Z2/1rS/5pOQXEBDkdBcQHpf00PeVIXbnVY0+fN6zq86MS8P1KSleUbVx9GhgwZwuTJdZvMbdOmTeTk5Fzy+RIRbwTS5bI1cKjc63x8LW6BqGrd1pUXMrORwEiAW2+9NcBNe2TjVIhp5kvoRMLAyx/sZNeRb6r9ffbBQs5dqHgtpuT8BZ5fnsu7Ww9WuU6nVk2ZMrhzneK6eIJ24MAB5s2bx9NPP12n7V2J0tJSGjQIfCjxhAkT+OUvfxm6gP53MhzdXv3v87fBhbMVy86XwPvP+iZpqsoPEuHeK78aD+FXV126dGHFihWMGjWqQvmuXbtYunQpO3fu5MiRI9x111188cUXREdHBy3OGVtnsPvU7mp/n3s8l3PfnatQ9u2Fb3lpy0ss/2J5let0+H4HftXzV3WKK9zqEKr+vF2NOjz6m99wNq/6OgRw585RkpsLzlG4dCln8/KwGqbob9SxAz/49a9r3XdpaSmPP/442dnZ/OhHP2LJkiXMmjWLDz74gJKSEvr06cP8+fMxM+bMmcMbb7xBgwYN6NSpE0uXLqW4uJgxY8awfft2SktLSU9P5/77K1yDZ9GiRWRmZjJ37lxGjBhB06ZNyczM5OjRo8ycOZMHH3wQgN/+9rcsW7aMs2fPMnToUF5++eUA/noi4oVAWuiqGtnqAtx+QOs65xY453o453q0aNEiwE174O+fwN6P4I4JEHOD19GIBEXlZK628kDNnDmTOXPmAL4TswEDBgCwYcMGhg8fTnx8PCdOnGDy5Mns27eP5ORkJk3yTTJUVFTEgw8+SIcOHRg2bBjOVf+VEx8fz5QpU+jWrRuJiYns3u07ETt16hRpaWkkJSXRq1cvcnNzAd+V/5EjR5Kamspjjz3GokWLSEtLY/DgwSQkJDB37lxee+01unbtSq9evTh16lSd/g5BVTmZq608QJFWVx07dqR9+/aX7P/999/n4YcfplGjRiQkJNC2bVu2bt1ap7/d5aqczNVWHqhIq8Pq1Ic6BDh35EjF14eD06Ph888/Z+TIkeTm5tK0aVPmzZvHs88+y7Zt29ixYwclJSWsWbMGgOnTp5OdnU1ubi5vvPEGANOmTWPAgAFs27aNTZs2MWnSJIqLi2vcZ0FBARkZGaxZs6as5W79+vXs2bOHrVu3kpOTQ1ZWFh9//DHgm/AkNTWV7t27s2DBgqC8bxGpm0AuleUDbcq9jgOOVLNsVev2r7Tu5gDXrV+cg43/DtfdAj1Heh2NSMBqa0lLmb6Rw4Ull5S3bhbL/4zqfcX77devH7Nnz2bs2LFkZmZy9uxZzp8/T0ZGBn379iUjIwPwnZTs2LGDnJwcwNcFLDs7m507d9KqVStSUlLYsmULd9xxR7X7at68OZ9++inz5s1j1qxZvPnmm0yZMoWuXbuyatUqNm7cyGOPPVa2j6ysLDIyMoiNjWXRokXs2LGD7Oxsvv32W9q2bcuMGTPIzs5mwoQJLFmyhPHjxwMwd+5clixZQo8ePZg9ezY33hjkIcG1taT9rou/u2UlN7SBJ668y14k1lVVDh8+TK9evcpex8XFcThIJ+IX1daSlro8lYLigkvKWzZpyVv3vHXF+43EOqzq83Y16rC2lrTzx46x7+5U33kBgHN89803tH5ttu8etXXQpk0bUlJSABg+fDhz5swhISGBmTNn8o9//INTp07RuXNnBg8eTFJSEsOGDSMtLY20tDTAl4itXr2aWbNmAb5b2Bw8WHVPi4vS0tKIioqiU6dOfPXVV2XbWb9+PV27dgV8Sf+ePXvo168fW7ZsoVWrVhw7doy7776bDh060K9fvzq9bxGpm0Ba6LYB7cwswcy+BzwMrA5w++uAVDO70T8ZSqq/LHxcnIDg5Rvh71vgXwbA9xp7HZVI0Ewa2J7YhhW7K8U2jGbSwEtbOC5H9+7dycrK4syZMzRq1IjevXuTmZnJX/7yF/r27Vvjuj179iQuLo6oqCiSk5M5cOBAjcs/8MADZfu8uGxGRgaPPvooAAMGDODkyZOcPn0a8I0hiY2NLVv/zjvv5Prrr6dFixbccMMNDB48GIDExMSy7Y0ePZp9+/aRk5NDy5Ytee655y73T1J3P3kJGsZWLGsY6yuvg0irq+pU1fJ0tadXH9dtHDHRMRXKYqJjGNdtXJ22G2l1WN3nrT7UYY33qK2jyu/FzHj66adZvnw527dv56mnniq7v9vatWt55plnyMrKonv37pSWluKc47333iMnJ4ecnBwOHjxIx44da9xno0aN/vk+/H9f5xwvvPBC2Xb27t3Lk08+CUCrVr7ZvW+++WaGDh3qSQupiFRUa0LnnCsFnsWXiOUBy5xzO83sFTMbAmBmt5tZPvAzYL6Z7fSvewr4d3xJ4TbgFX9ZeKg8AQHArlWaVU4iSlrX1rz6QCKtm8Vi+FrmXn0gkbSulwx3vSwNGzYkPj6et956iz59+tC3b182bdrEvn37LusEIzo6mtLS0oCWL79sTSd+TZo0qXZ/UVFRZa+joqLKtnfLLbcQHR1NVFQUTz31lDcnMUkPweA5vhY5zPc4eI6vvA4ira6qExcXx6FD/2zhzM/PLzs5vVoG3TaI9D7ptGzSEsNo2aQl6X3SGXTboDptN9LqsLrPW32owxrvUVtHBw8e5JNPPgHg3XffLWspbd68OUVFRSxf7htn+d1333Ho0CHuvPNOZs6cSWFhIUVFRQwcOJA//OEPZfWRfYUxDRw4kIULF1JUVAT4WrePHTtGcXExZ86cAaC4uJj169eHbGZOEQlcQKOTnXMfAh9WKnup3PNt+LpTVrXuQmBhHWL0zoZXfBMOlHe+xFdexxMokfokrWvrOidwVenXrx+zZs1i4cKFJCYmMnHiRLp3717hKvT1119fdoIQ7H2/8847vPjii2zevJnmzZvTtGnTK95eQUEBLVu2BGDlypXencQkPRSS759IqqvqDBkyhEceeYSJEydy5MgR9uzZQ8+ePYO+n9oMum1QnRO4qkRSHVb3easPdVjtPWqDoGPHjixevJhRo0bRrl07Ro8ezddff01iYiLx8fHcfvvtAFy4cIHhw4dz+vRpnHNMmDCBZs2a8eKLLzJ+/HiSkpJwzhEfH1825u5ypKamkpeXR+/evm731113HW+//TZFRUUMHToU8E3g8sgjj3DPPeE9eblIJAh8uqlr0en8yysXkQr69u3LtGnT6N27N02aNCEmJuaS7l833XQTKSkpdOnShXvvvZdBg4Jzopuens4TTzxBUlISjRs3ZvHiamaBDNDzzz9PTk4OZkZ8fDzz588PSpz1RSTV1cqVKxkzZgzHjx9n0KBBJCcns27dOjp37sxDDz1Ep06daNCgAa+//npQZ0f0WiTVYXWft0iuw/j4eHbt2nVJ+dSpU5k6deol5RfHRZYXGxtb5XdT//796d+/PwAjRoxgxIgRgG/Gy/IutsgBjBs3jnHjLu0K/Nlnn9X0NkTEA1bTbFZe6NGjh6s39zWpaQKCCTuufjwiAcrLy6u1m5WIiEio6P+QSN2YWZZzrkcgywYyKcq1K0QTEIiIiIiIiASDulzW5OI4lQ2v+LpZ3hDnS+Y0fk7kqhs6dChffvllhbIZM2YwcOBAjyKS6qiuwp/qUEQkfKjLpUgEysvLo0OHDld9Om8RERHnHLt371aXS5E6UJdLkWtcTEwMJ0+erHIqcRERkVBxznHy5EliYmJqX1hEgkJdLkUiUFxcHPn5+Rw/ftzrUERE5BoTExNDXFyVd7MSkRBQQicSgRo2bEhCQoLXYYiIiIhIiKnLpYiIiIiISJhSQiciIiIiIhKmlNCJiIiIiIiEqXp32wIzOw783es4qtAcOOF1EBLRdIxJKOn4klDS8SWhpONLQqm+Hl8/dM61CGTBepfQ1VdmlhnovSBEroSOMQklHV8SSjq+JJR0fEkoRcLxpS6XIiIiIiIiYUoJnYiIiIiISJhSQhe4BV4HIBFPx5iEko4vCSUdXxJKOr4klML++NIYOhERERERkTClFjoREREREZEwpYROREREREQkTCmhC4CZ3WNmn5vZXjOb7HU8EjnMrI2ZbTKzPDPbaWbjvI5JIo+ZRZtZtpmt8ToWiTxm1szMlpvZbv93WW+vY5LIYWYT/P8fd5jZu2YW43VMEr7MbKGZHTOzHeXKvm9mH5nZHv/jjV7GeCWU0NXCzKKB14F7gU7AL8ysk7dRSQQpBZ5zznUEegHP6PiSEBgH5HkdhESs/wD+7JzrAPwYHWsSJGbWGhgL9HDOdQGigYe9jUrC3CLgnkplk4ENzrl2wAb/67CihK52PYG9zrn9zrlzwFLgfo9jkgjhnCtwzn3qf34G34lQa2+jkkhiZnHAIOBNr2ORyGNmTYF+wH8BOOfOOecKvY1KIkwDINbMGgCNgSMexyNhzDn3MXCqUvH9wGL/88VA2lUNKgiU0NWuNXCo3Ot8dMItIWBm8UBX4G/eRiIR5vfA88B3XgciEek24Djwlr9b75tm1sTroCQyOOcOA7OAg0ABcNo5t97bqCQC3eKcKwDfhXbgZo/juWxK6GpnVZTpXg8SVGZ2HfAeMN45943X8UhkMLP7gGPOuSyvY5GI1QDoBvzROdcVKCYMuytJ/eQfy3Q/kAC0ApqY2XBvoxKpf5TQ1S4faFPudRxq7pcgMrOG+JK5d5xzK7yORyJKCjDEzA7g6y4+wMze9jYkiTD5QL5z7mLPguX4EjyRYLgL+NI5d9w5dx5YAfTxOCaJPF+ZWUsA/+Mxj+O5bEroarcNaGdmCWb2PXyDcVd7HJNECDMzfGNP8pxzr3kdj0QW59wLzrk451w8vu+ujc45Xd2WoHHOHQUOmVl7f9FPgF0ehiSR5SDQy8wa+/9f/gRNuiPBtxp43P/8ceB9D2O5Ig28DqC+c86VmtmzwDp8systdM7t9DgsiRwpwKPAdjPL8Zf92jn3oYcxiYhcjjHAO/6LnvuBJzyORyKEc+5vZrYc+BTfrNDZwAJvo5JwZmbvAv2B5maWD0wBpgPLzOxJfBcRfuZdhFfGnNNwMBERERERkXCkLpciIiIiIiJhSgmdiIiIiIhImFJCJyIiIiIiEqaU0ImIiIiIiIQpJXQiIiIiIiJhSgmdiIhELDO7YGY55X4mB3Hb8Wa2I1jbExERuRK6D52IiESyEudcstdBiIiIhIpa6ERE5JpjZgfMbIaZbfX/tPWX/9DMNphZrv/xVn/5LWa20sw+8//08W8q2sz+08x2mtl6M4v17E2JiMg1SQmdiIhEsthKXS5/Xu533zjnegJzgd/7y+YCS5xzScA7wBx/+Rzg/5xzPwa6ATv95e2A151znYFC4N9C/H5EREQqMOec1zGIiIiEhJkVOeeuq6L8ADDAObffzBoCR51zN5nZCaClc+68v7zAOdfczI4Dcc65s+W2EQ985Jxr53/9K6Chc25q6N+ZiIiIj1roRETkWuWqeV7dMlU5W+75BTQ2XURErjIldCIicq36ebnHT/zP/wo87H8+DMjwP98AjAYws2gza3q1ghQREamJriSKiEgkizWznHKv/+ycu3jrgkZm9jd8Fzd/4S8bCyw0s0nAceAJf/k4YIGZPYmvJW40UBDy6EVERGqhMXQiInLN8Y+h6+GcO+F1LCIiInWhLpciIiIiIiJhSi10IiIiIiIiYUotdCIiIiIiImFKCZ2IiIiIiEiYUkInIiIiIiISppTQiYiIiIiIhCkldCIiIiIiImHq/wF5TFateCLJDwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff644423cc0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Batch Normalization)','Epoch', solver_bsize, bn_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 2:\n",
    "Describe the results of this experiment. What does this imply about the relationship between batch normalization and batch size? Why is this relationship observed?\n",
    "\n",
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization\n",
    "Batch normalization has proved to be effective in making networks easier to train, but the dependency on batch size makes it less useful in complex networks which have a cap on the input batch size due to hardware limitations. \n",
    "\n",
    "Several alternatives to batch normalization have been proposed to mitigate this problem; one such technique is Layer Normalization [4]. Instead of normalizing over the batch, we normalize over the features. In other words, when using Layer Normalization, each feature vector corresponding to a single datapoint is normalized based on the sum of all terms within that feature vector.\n",
    "\n",
    "[4] [Ba, Jimmy Lei, Jamie Ryan Kiros, and Geoffrey E. Hinton. \"Layer Normalization.\" stat 1050 (2016): 21.](https://arxiv.org/pdf/1607.06450.pdf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 3:\n",
    "Which of these data preprocessing steps is analogous to batch normalization, and which is analogous to layer normalization?\n",
    "\n",
    "1. Scaling each image in the dataset, so that the RGB channels for each row of pixels within an image sums up to 1.\n",
    "2. Scaling each image in the dataset, so that the RGB channels for all pixels within an image sums up to 1.  \n",
    "3. Subtracting the mean image of the dataset from each image in the dataset.\n",
    "4. Setting all RGB values to either 0 or 1 depending on a given threshold.\n",
    "\n",
    "## Answer:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization: Implementation\n",
    "\n",
    "Now you'll implement layer normalization. This step should be relatively straightforward, as conceptually the implementation is almost identical to that of batch normalization. One significant difference though is that for layer normalization, we do not keep track of the moving moments, and the testing phase is identical to the training phase, where the mean and variance are directly calculated per datapoint.\n",
    "\n",
    "Here's what you need to do:\n",
    "\n",
    "* In `cs231n/layers.py`, implement the forward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the cell below to check your results.\n",
    "* In `cs231n/layers.py`, implement the backward pass for layer normalization in the function `layernorm_backward`. \n",
    "\n",
    "Run the second cell below to check your results.\n",
    "* Modify `cs231n/classifiers/fc_net.py` to add layer normalization to the `FullyConnectedNet`. When the `normalization` flag is set to `\"layernorm\"` in the constructor, you should insert a layer normalization layer before each ReLU nonlinearity. \n",
    "\n",
    "Run the third cell below to run the batch size experiment on layer normalization."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Before layer normalization:\n",
      "  means:  [-59.06673243 -47.60782686 -43.31137368 -26.40991744]\n",
      "  stds:   [10.07429373 28.39478981 35.28360729  4.01831507]\n",
      "\n",
      "After layer normalization (gamma=1, beta=0)\n",
      "  means:  [-4.81096644e-16  0.00000000e+00  7.40148683e-17 -5.55111512e-16]\n",
      "  stds:   [0.99999995 0.99999999 1.         0.99999969]\n",
      "\n",
      "After layer normalization (gamma= [3. 3. 3.] , beta= [5. 5. 5.] )\n",
      "  means:  [5. 5. 5. 5.]\n",
      "  stds:   [2.99999985 2.99999998 2.99999999 2.99999907]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Check the training-time forward pass by checking means and variances\n",
    "# of features both before and after layer normalization   \n",
    "\n",
    "# Simulate the forward pass for a two-layer network\n",
    "np.random.seed(231)\n",
    "N, D1, D2, D3 =4, 50, 60, 3\n",
    "X = np.random.randn(N, D1)\n",
    "W1 = np.random.randn(D1, D2)\n",
    "W2 = np.random.randn(D2, D3)\n",
    "a = np.maximum(0, X.dot(W1)).dot(W2)\n",
    "\n",
    "print('Before layer normalization:')\n",
    "print_mean_std(a,axis=1)\n",
    "\n",
    "gamma = np.ones(D3)\n",
    "beta = np.zeros(D3)\n",
    "# Means should be close to zero and stds close to one\n",
    "print('After layer normalization (gamma=1, beta=0)')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)\n",
    "\n",
    "gamma = np.asarray([3.0,3.0,3.0])\n",
    "beta = np.asarray([5.0,5.0,5.0])\n",
    "# Now means should be close to beta and stds close to gamma\n",
    "print('After layer normalization (gamma=', gamma, ', beta=', beta, ')')\n",
    "a_norm, _ = layernorm_forward(a, gamma, beta, {'mode': 'train'})\n",
    "print_mean_std(a_norm,axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dx error:  1.433615657860454e-09\n",
      "dgamma error:  4.519489546032799e-12\n",
      "dbeta error:  2.276445013433725e-12\n"
     ]
    }
   ],
   "source": [
    "# Gradient check batchnorm backward pass\n",
    "np.random.seed(231)\n",
    "N, D = 4, 5\n",
    "x = 5 * np.random.randn(N, D) + 12\n",
    "gamma = np.random.randn(D)\n",
    "beta = np.random.randn(D)\n",
    "dout = np.random.randn(N, D)\n",
    "\n",
    "ln_param = {}\n",
    "fx = lambda x: layernorm_forward(x, gamma, beta, ln_param)[0]\n",
    "fg = lambda a: layernorm_forward(x, a, beta, ln_param)[0]\n",
    "fb = lambda b: layernorm_forward(x, gamma, b, ln_param)[0]\n",
    "\n",
    "dx_num = eval_numerical_gradient_array(fx, x, dout)\n",
    "da_num = eval_numerical_gradient_array(fg, gamma.copy(), dout)\n",
    "db_num = eval_numerical_gradient_array(fb, beta.copy(), dout)\n",
    "\n",
    "_, cache = layernorm_forward(x, gamma, beta, ln_param)\n",
    "dx, dgamma, dbeta = layernorm_backward(dout, cache)\n",
    "\n",
    "#You should expect to see relative errors between 1e-12 and 1e-8\n",
    "print('dx error: ', rel_error(dx_num, dx))\n",
    "print('dgamma error: ', rel_error(da_num, dgamma))\n",
    "print('dbeta error: ', rel_error(db_num, dbeta))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Layer Normalization and batch size\n",
    "\n",
    "We will now run the previous batch size experiment with layer normalization instead of batch normalization. Compared to the previous experiment, you should see a markedly smaller influence of batch size on the training history!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "No normalization: batch size =  5\n",
      "Normalization: batch size =  5\n",
      "Normalization: batch size =  10\n",
      "Normalization: batch size =  50\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7ff6457917f0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ln_solvers_bsize, solver_bsize, batch_sizes = run_batchsize_experiments('layernorm')\n",
    "\n",
    "plt.subplot(2, 1, 1)\n",
    "plot_training_history('Training accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.train_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "plt.subplot(2, 1, 2)\n",
    "plot_training_history('Validation accuracy (Layer Normalization)','Epoch', solver_bsize, ln_solvers_bsize, \\\n",
    "                      lambda x: x.val_acc_history, bl_marker='-^', bn_marker='-o', labels=batch_sizes)\n",
    "\n",
    "plt.gcf().set_size_inches(15, 10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inline Question 4:\n",
    "When is layer normalization likely to not work well, and why?\n",
    "\n",
    "1. Using it in a very deep network\n",
    "2. Having a very small dimension of features\n",
    "3. Having a high regularization term\n",
    "\n",
    "\n",
    "## Answer:\n",
    "\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
